swift-optimise

Optimize Swift 6.2 and SwiftUI codebases for performance and concurrency.

193|17|Updated Jan 16, 2026
One-click install
npx skills add https://github.com/pproenca/dot-skills --skill swift-optimise
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: swift-optimise
Source: https://github.com/pproenca/dot-skills/tree/main/skills/.experimental/swift-optimise
Command: npx skills add https://github.com/pproenca/dot-skills --skill swift-optimise

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill addresses performance bottlenecks in Swift and SwiftUI applications, focusing on modern concurrency patterns, efficient rendering, and smooth animations.

Core Features & Use Cases

  • Concurrency Optimization: Migrates from Combine to async/await, enforces strict concurrency with Swift 6, and leverages actors for safe state management.
  • Rendering Performance: Improves scroll and UI responsiveness through view decomposition and efficient rendering techniques.
  • Animation Tuning: Ensures fluid and native-feeling animations using springs and gesture-driven effects.
  • Use Case: When profiling reveals slow scrolling in a list or janky animations during view transitions, consult this Skill for targeted optimizations.

Quick Start

Apply the swift-optimise skill to refactor the provided Swift code to use @MainActor for UI updates.

Frequently Asked Questions about swift-optimise

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I optimize SwiftUI rendering for slow scrolling lists?

To optimize SwiftUI rendering for slow scrolling, apply view decomposition and efficient state management techniques. Refactoring complex views into smaller components prevents unnecessary redraws and improves UI responsiveness.

How do I migrate from Combine to async/await in Swift 6?

Migrating from Combine to async/await in Swift 6 involves enforcing strict concurrency rules and leveraging actors for safe state management. This approach replaces reactive streams with structured concurrency to resolve bottlenecks.

What is the best way to fix janky animations in SwiftUI views?

The best way to fix janky animations in SwiftUI is by tuning your animation parameters to use native springs and gesture-driven effects. This ensures fluid transitions by aligning with the system's natural rendering mechanics.

Does this approach to Swift concurrency require a specific architecture?

Yes, this Swift concurrency approach targets modular MVVM-C architectures. It specifically addresses actor isolation and async/await adoption within this structured environment to ensure safe state management and strict concurrency.

Why does my Swift UI thread block during async tasks?

Your Swift UI thread blocks during async tasks when state updates occur outside the main actor. Applying @MainActor for UI updates and enforcing strict concurrency rules resolves these bottlenecks by isolating UI state mutations.