Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design
Codex

Anwendungsfall für Codex

Ein Grundgerüst für eine Mac-App erstellen

Erstelle mit Codex das Grundgerüst für eine native Mac-App in SwiftUI mit Seitenleiste, Detailbereich, Inspektor, Befehlen und Einstellungen.

Schwierigkeitsgrad Advanced
Zeithorizont 1h

Setze deine App-Idee mit Codex und dem Plugin „Build macOS Apps“ als native Mac-App mit NavigationSplitView um. Sorge dafür, dass die Auswahl in der Seitenleiste erhalten bleibt, ergänze Menüs, Symbolleisten und Tastaturkurzbefehle und verschiebe die Einstellungen in eine eigene Settings-Szene.

Besonders geeignet für

  • Ideen für neue Mac-Apps oder Konzepte, die zunächst für das iPad oder das Web gedacht waren und eine Desktop-Oberfläche mit dauerhaft verfügbarer Navigation, Menüs, Symbolleisten und Tastaturkurzbefehlen brauchen
  • Editoren, Bibliotheks-, Verwaltungs- oder Review-Tools, bei denen die Auswahl in der Seitenleiste den Inhalt des Detailbereichs bestimmt und ein Inspektor zusätzliche Metadaten anzeigt oder weitere Aktionen anbietet
  • Mac-Apps, deren Einstellungen sich in einem eigenen Fenster öffnen sollen, statt als weitere Ansicht im Hauptfenster zu erscheinen

Inhalt

    ← Alle Anwendungsfälle

    Ein Grundgerüst für eine Mac-App erstellen

    Erstelle mit Codex das Grundgerüst für eine native Mac-App in SwiftUI mit Seitenleiste, Detailbereich, Inspektor, Befehlen und Einstellungen.

    Setze deine App-Idee mit Codex und dem Plugin „Build macOS Apps“ als native Mac-App mit NavigationSplitView um. Sorge dafür, dass die Auswahl in der Seitenleiste erhalten bleibt, ergänze Menüs, Symbolleisten und Tastaturkurzbefehle und verschiebe die Einstellungen in eine eigene Settings-Szene.

    Advanced
    1h

    Setze deine App-Idee mit Codex und dem Plugin „Build macOS Apps“ als native Mac-App mit NavigationSplitView um. Sorge dafür, dass die Auswahl in der Seitenleiste erhalten bleibt, ergänze Menüs, Symbolleisten und Tastaturkurzbefehle und verschiebe die Einstellungen in eine eigene Settings-Szene.

    Advanced
    1h

    Besonders geeignet für

    • Ideen für neue Mac-Apps oder Konzepte, die zunächst für das iPad oder das Web gedacht waren und eine Desktop-Oberfläche mit dauerhaft verfügbarer Navigation, Menüs, Symbolleisten und Tastaturkurzbefehlen brauchen
    • Editoren, Bibliotheks-, Verwaltungs- oder Review-Tools, bei denen die Auswahl in der Seitenleiste den Inhalt des Detailbereichs bestimmt und ein Inspektor zusätzliche Metadaten anzeigt oder weitere Aktionen anbietet
    • Mac-Apps, deren Einstellungen sich in einem eigenen Fenster öffnen sollen, statt als weitere Ansicht im Hauptfenster zu erscheinen

    Skills und Plug-ins

    • Nutze die Skills für SwiftUI-Muster unter macOS, Fensterverwaltung, AppKit-Integration sowie das Kompilieren und Starten der App. Erstelle damit ein Layout mit Seitenleiste, Detailbereich und Inspektor und binde Menüs und Einstellungen an. Teste zuerst das Grundgerüst und dann die App nach jedem weiteren Schritt.
    Skill Nutzen
    Build macOS Apps Nutze die Skills für SwiftUI-Muster unter macOS, Fensterverwaltung, AppKit-Integration sowie das Kompilieren und Starten der App. Erstelle damit ein Layout mit Seitenleiste, Detailbereich und Inspektor und binde Menüs und Einstellungen an. Teste zuerst das Grundgerüst und dann die App nach jedem weiteren Schritt.

    Prompt für den Einstieg

    Erstelle mit dem Plugin „Build macOS Apps“ das Grundgerüst für eine native Mac-App in SwiftUI. Meine App-Idee ist [describe your app idea]. Die App soll eine Seitenleiste, einen Detailbereich, einen Inspektor, Befehle und Einstellungen haben. Vorgaben: - Lege zuerst das Szenenmodell fest. Verwende für das Hauptfenster vorzugsweise `WindowGroup` und ergänze für die Einstellungen eine eigene `Settings`-Szene. - Baue die Hauptansicht mit `NavigationSplitView` auf und verwalte den Auswahlzustand explizit. Verwende eine native Liste im Stil `.sidebar`, einen Detailbereich und einen mit `inspector(isPresented:)` einblendbaren Inspektor für zusätzliche Metadaten oder Bedienelemente. - Halte die Zeilen der Seitenleiste schlicht und verwende native Elemente. Jede Zeile enthält ein Symbol, eine Titelzeile und höchstens eine kurze Zusatzzeile. Gestalte nur dann sämtliche Zeilen als große, individuelle Karten, wenn es dafür einen triftigen Grund im Produktkonzept gibt. - Mache wichtige Aktionen über `commands` auf Szenenebene, `CommandMenu`, Schaltflächen in der Symbolleiste und Tastaturkurzbefehle zugänglich. Jede kritische Aktion muss sich auch ohne Gesten ausführen lassen. - Verwende `@SceneStorage` für den UI-Zustand des jeweiligen Fensters und `@AppStorage` für die Einstellungen. Verwalte die Auswahl in der übergeordneten Ansicht und verknüpfe Seitenleiste und Detailbereich über explizite Bindings für diese Auswahl. - Bevorzuge Systemmaterialien, semantische Farben und die Standardhintergründe für Seitenleisten. Verwende eigene Stile nur bei Bedarf und nur für Inhaltskarten im Detailbereich oder im Inspektor. - Binde AppKit nur dann ein, wenn sich ein bestimmtes Desktop-Verhalten mit SwiftUI nicht sauber umsetzen lässt. Beschränke die Anbindung auf diesen Fall. - Erstelle oder aktualisiere `script/build_and_run.sh`. Prüfe mit einem möglichst kleinen, aussagekräftigen Test, ob sich die App kompilieren und starten lässt. Nenne mir die genauen Befehle, die du ausgeführt hast. Liefere mir Folgendes: - die Szenenstruktur und die Hauptansichten für Seitenleiste, Detailbereich und Inspektor - die Anbindung der Aktionen an Menüs, Symbolleisten und Tastaturkurzbefehle - die Settings-Szene und das Zustandsmodell für die Einstellungen - gegebenenfalls die AppKit-Anbindung mit einer Begründung, warum sie nötig war - die Schritte, mit denen du das Kompilieren und Starten geprüft hast, sowie gegebenenfalls deine Empfehlungen zur weiteren Verbesserung der Bedienung auf dem Mac
    Erstelle mit dem Plugin „Build macOS Apps“ das Grundgerüst für eine native Mac-App in SwiftUI. Meine App-Idee ist [describe your app idea]. Die App soll eine Seitenleiste, einen Detailbereich, einen Inspektor, Befehle und Einstellungen haben. Vorgaben: - Lege zuerst das Szenenmodell fest. Verwende für das Hauptfenster vorzugsweise `WindowGroup` und ergänze für die Einstellungen eine eigene `Settings`-Szene. - Baue die Hauptansicht mit `NavigationSplitView` auf und verwalte den Auswahlzustand explizit. Verwende eine native Liste im Stil `.sidebar`, einen Detailbereich und einen mit `inspector(isPresented:)` einblendbaren Inspektor für zusätzliche Metadaten oder Bedienelemente. - Halte die Zeilen der Seitenleiste schlicht und verwende native Elemente. Jede Zeile enthält ein Symbol, eine Titelzeile und höchstens eine kurze Zusatzzeile. Gestalte nur dann sämtliche Zeilen als große, individuelle Karten, wenn es dafür einen triftigen Grund im Produktkonzept gibt. - Mache wichtige Aktionen über `commands` auf Szenenebene, `CommandMenu`, Schaltflächen in der Symbolleiste und Tastaturkurzbefehle zugänglich. Jede kritische Aktion muss sich auch ohne Gesten ausführen lassen. - Verwende `@SceneStorage` für den UI-Zustand des jeweiligen Fensters und `@AppStorage` für die Einstellungen. Verwalte die Auswahl in der übergeordneten Ansicht und verknüpfe Seitenleiste und Detailbereich über explizite Bindings für diese Auswahl. - Bevorzuge Systemmaterialien, semantische Farben und die Standardhintergründe für Seitenleisten. Verwende eigene Stile nur bei Bedarf und nur für Inhaltskarten im Detailbereich oder im Inspektor. - Binde AppKit nur dann ein, wenn sich ein bestimmtes Desktop-Verhalten mit SwiftUI nicht sauber umsetzen lässt. Beschränke die Anbindung auf diesen Fall. - Erstelle oder aktualisiere `script/build_and_run.sh`. Prüfe mit einem möglichst kleinen, aussagekräftigen Test, ob sich die App kompilieren und starten lässt. Nenne mir die genauen Befehle, die du ausgeführt hast. Liefere mir Folgendes: - die Szenenstruktur und die Hauptansichten für Seitenleiste, Detailbereich und Inspektor - die Anbindung der Aktionen an Menüs, Symbolleisten und Tastaturkurzbefehle - die Settings-Szene und das Zustandsmodell für die Einstellungen - gegebenenfalls die AppKit-Anbindung mit einer Begründung, warum sie nötig war - die Schritte, mit denen du das Kompilieren und Starten geprüft hast, sowie gegebenenfalls deine Empfehlungen zur weiteren Verbesserung der Bedienung auf dem Mac

    Mit dem Szenenmodell für den Mac beginnen

    In diesem Anwendungsfall entwickelst du aus einer App-Idee das Grundgerüst einer Mac-App. Die Oberfläche soll sich am Desktop vertraut anfühlen, ohne dass du dafür eine auf Touchbedienung ausgelegte Navigation auf ein größeres Fenster überträgst. Lass Codex zuerst das Szenenmodell wählen und dann das Hauptfenster gestalten. Dazu gehören eine Seitenleiste, in der die Auswahl erhalten bleibt, eine Detailansicht und ein Inspektor für zusätzliche Bedienelemente oder Metadaten.

    Oberfläche einer nativen Mac-App mit einem ausgewählten Eintrag in der Seitenleiste und dem zugehörigen Inhalt in der Detailansicht

    Verwende das Plugin „Build macOS Apps“, wenn Codex diese Desktop-Struktur umsetzen und die App bei jeder Iteration direkt aus der Shell kompilieren und starten soll. Der enthaltene Skill für SwiftUI-Muster unter macOS eignet sich für die Gestaltung von Szenen, Seitenleisten, Inspektoren, Befehlen und Einstellungen. Er hilft auch bei der gezielten Anbindung von AppKit, wenn SwiftUI ein bestimmtes Mac-Verhalten nicht vollständig abdeckt.

    Seitenleiste, Detailansicht und Inspektor erstellen

    Nutze bevorzugt NavigationSplitView, wenn die Navigation sichtbar bleiben und die Auswahl erhalten bleiben soll. Verwende für die Zeilen der Seitenleiste schlichte native Elemente und für den Hintergrund die Systemvorgabe. Eigene Karten oder umfangreiche Metadaten gehören in die Detailansicht oder den Inspektor.

    import SwiftUI
    
    struct Item: Identifiable, Hashable {
      let id: String
      let title: String
      let systemImage: String
    }
    let items = [Item(id: "notes", title: "Notes", systemImage: "note.text"), Item(id: "photos", title: "Photos", systemImage: "photo")]
    
    struct ItemDetailView: View {
      let selection: String?
      var body: some View { Text(selection ?? "Select an item").frame(maxWidth: .infinity, maxHeight: .infinity) }
    }
    struct ItemInspectorView: View {
      let selection: String?
      var body: some View { Text("Metadata: \(selection ?? "No selection")").padding().frame(minWidth: 220) }
    }
    @MainActor final class LibraryStore: ObservableObject {
      @Published var entries = items
      @Published var selection: String?
      @Published var showInspector = true
      func addItem() {
        let item = Item(id: UUID().uuidString, title: "New Item", systemImage: "doc")
        entries.append(item)
        selection = item.id
      }
    }
    
    struct LibraryRootView: View {
      @StateObject private var store = LibraryStore()
      @SceneStorage("LibraryRootView.selection") private var savedSelection: Item.ID?
      @SceneStorage("LibraryRootView.showInspector") private var savedShowInspector = true
    
      var body: some View {
        NavigationSplitView {
          List(selection: $store.selection) {
            ForEach(store.entries) { item in
              Label(item.title, systemImage: item.systemImage)
                .tag(item.id)
            }
          }
          .listStyle(.sidebar)
          .navigationTitle("Library")
        } detail: {
          ItemDetailView(selection: store.selection)
            .inspector(isPresented: $store.showInspector) {
              ItemInspectorView(selection: store.selection)
            }
        }
        .focusedSceneObject(store)
        .onAppear {
          store.selection = savedSelection
          store.showInspector = savedShowInspector
        }
        .onChange(of: store.selection) { _, selection in
          savedSelection = selection
        }
        .onChange(of: store.showInspector) { _, showInspector in
          savedShowInspector = showInspector
        }
      }
    }

    Braucht die App besondere Regeln für die Breite der Fensterbereiche, eine systemnahe Fensterkoordination oder ein eigenes Verhalten in der Responder-Kette? Bitte Codex in diesem Fall, das SwiftUI-Grundgerüst beizubehalten und nur so viel AppKit-Code zu ergänzen, wie dafür nötig ist.

    Befehle, Symbolleisten und Tastaturkurzbefehle für den Desktop einrichten

    Wer die App auf dem Mac nutzt, sollte wichtige Aktionen in der Menüleiste und der Symbolleiste leicht finden und die zugehörigen Tastaturkurzbefehle erkennen können. Lass Codex commands auf Szenenebene, kontextabhängige Menüeinträge und Schaltflächen in der Symbolleiste mit denselben App-Aktionen verknüpfen. So muss am Desktop niemand nach Funktionen suchen, die nur per Geste erreichbar sind.

    @main
    struct LibraryApp: App {
      @FocusedObject private var store: LibraryStore?
      var body: some Scene {
        WindowGroup {
          LibraryRootView()
        }
        .commands {
          CommandMenu("Library") {
            Button("New Item") {
              store?.addItem()
            }
            .keyboardShortcut("n")
            .disabled(store == nil)
    
            Button("Toggle Inspector") {
              store?.showInspector.toggle()
            }
            .keyboardShortcut("i", modifiers: [.command, .option])
            .disabled(store == nil)
          }
        }
    
        Settings {
          LibrarySettingsView()
        }
      }
    }

    Nutze FocusedValue, den Szenenzustand oder einen expliziten Auswahlzustand, wenn ein Befehl für den aktuell in der Detailansicht angezeigten Eintrag gelten soll. Würde ein Tastaturkurzbefehl an mehreren Stellen registriert, lass Codex die Zuständigkeit an einer Stelle bündeln, damit die App den Befehl eindeutig zuordnet.

    App-Einstellungen in Settings verwalten

    Verwende für die App-Einstellungen eine eigene Settings-Szene und speichere Einstellungen, die dauerhaft gelten sollen, mit @AppStorage. Ein separates Einstellungsfenster entspricht auf dem Mac meist eher den Erwartungen als eine Einstellungsansicht, zu der man innerhalb des Hauptfensters navigiert.

    struct LibrarySettingsView: View {
      @AppStorage("showItemMetadata") private var showItemMetadata = true
    
      var body: some View {
        TabView {
          Form {
            Toggle("Show Item Metadata", isOn: $showItemMetadata)
          }
          .tabItem { Label("General", systemImage: "gearshape") }
        }
        .frame(width: 460, height: 260)
        .scenePadding()
      }
    }

    Die App-Idee im Prompt beschreiben und das Grundgerüst prüfen

    Am besten beschreibst du in deinem Prompt die App-Idee, die wichtigsten Objekte, mit denen die App arbeitet, und die zentralen Aktionen. Bitte Codex dann, zuerst das Grundgerüst der Desktop-App passend zu diesem Ablauf zu erstellen. Lass den Agenten kurz prüfen, ob sich die App kompilieren und starten lässt. Anschließend soll er zusammenfassen, wie die Szenen aufgebaut und die Befehle angebunden sind, welche Komponenten welchen Zustand verwalten und wo eine Anbindung an AppKit nötig war.

    Tipps für die Praxis

    Die Seitenleiste mit nativen Elementen gestalten

    Verwende pro Zeile in der Seitenleiste ein Symbol, eine Titelzeile und höchstens eine kurze Zusatzzeile. Platziere ausführlichere Karten, Zähler und Metadaten in der Detailansicht oder im Inspektor, damit die Liste in der Seitenleiste übersichtlich bleibt.

    Einstellungen über das App-Menü zugänglich machen

    Gilt eine Einstellung für die gesamte App, lass Codex das zugehörige Bedienelement in Settings platzieren, die Auswahl mit @AppStorage speichern und die Einstellungen über das App-Menü zugänglich machen. So brauchst du keine zusätzliche Einstellungsansicht in der Navigation des Hauptfensters.

    AppKit gezielt für einzelne Desktop-Funktionen einsetzen

    Benötigt die Funktion Dialoge zum Öffnen oder Speichern, Kontrolle über den First Responder oder eine eigene NSView, binde AppKit nur an dieser Stelle ein. SwiftUI verwaltet weiterhin das Zustandsmodell, und du sparst dir die Neuimplementierung des gesamten Fensters in AppKit.

    Tech-Stack

    Was du brauchst

    App-Grundgerüst mit geteilter Ansicht

    Standardoptionen

    NavigationSplitView, Listen im Stil .sidebar und inspector(isPresented:)

    Warum du es brauchst

    Eine dauerhaft sichtbare Seitenleiste, ein Detailbereich und ein Inspektor entsprechen dem üblichen Aufbau von Mac-Apps besser als eine für Touchscreens ausgelegte Navigation, bei der jede neue Ansicht die vorherige ersetzt.

    Was du brauchst

    Desktop-Aktionen und Einstellungen

    Standardoptionen

    commands, CommandMenu, Tastaturkurzbefehle und eine Settings-Szene

    Warum du es brauchst

    Mit Befehlen in der Menüleiste, Tastaturkurzbefehlen und einem eigenen Einstellungsfenster lässt sich die Funktion so bedienen, wie du es von Mac-Apps kennst. So wirkt sie weniger wie eine vergrößerte iOS-Ansicht.

    Was du brauchst

    Zuständigkeit für die Zustandsverwaltung

    Standardoptionen

    @State, @SceneStorage, @AppStorage und explizite Bindings für die Auswahl

    Warum du es brauchst

    Codex kann die Auswahl in der Seitenleiste, die Sichtbarkeit des Inspektors und die persönlichen Einstellungen konsistent verwalten, ohne dafür routinemäßig ein eigenes ViewModel anzulegen.

    Was du brauchst

    AppKit für Sonderfälle

    Standardoptionen

    AppKit gezielt über NSViewRepresentable oder NSWindow anbinden

    Warum du es brauchst

    Nutze AppKit nur für plattformspezifisches Verhalten, das sich mit SwiftUI nicht sauber umsetzen lässt. Verwalte den Zustand der Szene und die aktuelle Auswahl weiterhin zentral in SwiftUI.

    Was du brauchst Standardoptionen Warum du es brauchst
    App-Grundgerüst mit geteilter Ansicht NavigationSplitView , Listen im Stil .sidebar und inspector(isPresented:) Eine dauerhaft sichtbare Seitenleiste, ein Detailbereich und ein Inspektor entsprechen dem üblichen Aufbau von Mac-Apps besser als eine für Touchscreens ausgelegte Navigation, bei der jede neue Ansicht die vorherige ersetzt.
    Desktop-Aktionen und Einstellungen commands , CommandMenu , Tastaturkurzbefehle und eine Settings -Szene Mit Befehlen in der Menüleiste, Tastaturkurzbefehlen und einem eigenen Einstellungsfenster lässt sich die Funktion so bedienen, wie du es von Mac-Apps kennst. So wirkt sie weniger wie eine vergrößerte iOS-Ansicht.
    Zuständigkeit für die Zustandsverwaltung @State , @SceneStorage , @AppStorage und explizite Bindings für die Auswahl Codex kann die Auswahl in der Seitenleiste, die Sichtbarkeit des Inspektors und die persönlichen Einstellungen konsistent verwalten, ohne dafür routinemäßig ein eigenes ViewModel anzulegen.
    AppKit für Sonderfälle AppKit gezielt über NSViewRepresentable oder NSWindow anbinden Nutze AppKit nur für plattformspezifisches Verhalten, das sich mit SwiftUI nicht sauber umsetzen lässt. Verwalte den Zustand der Szene und die aktuelle Auswahl weiterhin zentral in SwiftUI.

    Verwandte Anwendungsfälle