SwiftUI Microinteractions Pro

    1

    Production-ready SwiftUI microinteractions featuring liquid morphs, physics-based gestures, and iOS 26 Liquid Glass.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    SwiftUI Microinteractions Pro

    Example session with this skill installed

    Create a premium morphing player FAB for a music app. It should be a glass capsule that morphs into a circle when scrolling, using iOS 26 Liquid Glass and snappy physics.

    • Read your context and instructions
    • Compiled the swiftui microinteractions pro

    I have generated the morphing player FAB using the Liquid Glass archetype. The component uses a single view tree to ensure a fluid morph between the pill and circle states without cross-fading.

    SwiftUI Morphing Player

    import SwiftUI
    
    // MARK: - Main View
    struct MorphingPlayerFAB: View {
        @State private var isExpanded = true
        @State private var appeared = false
        
        // Snappy physics: response 0.35, damping 0.6
        private let spring = Animation.spring(response: 0.35, dampingFraction: 0.6)
        
        var body: some View {
            ZStack(alignment: .bottom) {
                // Background grid to show off glass refraction
                ImageTileGrid()
                    .opacity(0.4)
                
                HStack(spacing: isExpanded ? 12 : 0) {
                    // Shared element: Album Art
                    RoundedRectangle(cornerRadius: 12)
                        .fill(Color.gray.opacity(0.3))
                        .frame(width: 48, height: 48)
                        .overlay(Image(systemName: "music.note").foregroundStyle(.white.opacity(0.8)))
                        .padding(.leading, 8)
                    
                    if isExpanded {
                        VStack(alignment: .leading, spacing: 2) {
                            Text("Starlight Drift")
                                .font(.system(size: 15, weight: .semibold))
                                .foregroundStyle(.white)
                            Text("Lunar Collective")
                                .font(.system(size: 13))
                                .foregroundStyle(.white.opacity(0.6))
                        }
                        .transition(.opacity.combined(with: .move(edge: .trailing)))
                        
                        Spacer()
                        
                        Image(systemName: "pause.fill")
                            .font(.system(size: 20))
                            .foregroundStyle(.white)
                            .padding(.trailing, 16)
                    }
                }
                .frame(width: isExpanded ? 320 : 64, height: 64)
                .background {
                    if #available(iOS 26.0, *) {
                        Capsule()
                            .fill(.clear)
                            .glassEffect(.regular.interactive(), in: Capsule())
                    } else {
                        Capsule()
                            .fill(.ultraThinMaterial)
                            .overlay(Capsule().stroke(.white.opacity(0.1), lineWidth: 0.5))
                    }
                }
                .clipShape(Capsule())
                .shadow(color: .black.opacity(0.2), radius: 20, y: 10)
                .padding(.bottom, 40)
                .onTapGesture {
                    UIImpactFeedbackGenerator(style: .medium).impactOccurred()
                    withAnimation(spring) {
                        isExpanded.toggle()
                    }
                }
            }
            .ignoresSafeArea()
        }
    }
    
    private struct ImageTileGrid: View {
        var body: some View {
            let columns = [GridItem(.flexible()), GridItem(.flexible())]
            ScrollView {
                LazyVGrid(columns: columns, spacing: 10) {
                    ForEach(0..<20) { i in
                        RoundedRectangle(cornerRadius: 20)
                            .fill(LinearGradient(colors: [.blue, .purple], startPoint: .topLeading, endPoint: .bottomTrailing))
                            .frame(height: 200)
                    }
                }
                .padding()
            }
        }
    }
    

    Next steps

    1. Integrate the isExpanded state with your ScrollView offset to auto-collapse the player on scroll.
    2. Replace the RoundedRectangle placeholder with AsyncImage to fetch real album artwork.
    3. Add HapticFeedback.selectionChanged() to the playback toggle for tactile confirmation.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop shipping static, lifeless mobile interfaces. Modern iOS development demands high-fidelity motion that feels integrated with the hardware, not just bolted on.

    This skill delivers production-ready SwiftUI code for premium microinteractions. It specializes in physics-based gestures, HapticFeedback integration, and the iOS 26 Liquid Glass API. Whether you need a simple symbol animation or a complex multi-phase morphing interface, it generates compilable Swift files that follow Apple HIG defaults while pushing the boundaries of what is possible with SwiftUI and Metal.

    What it does

    • Premium Morphing creates interfaces that split and merge like liquid, including player FABs that morph from pills to circles.
    • Physics Integration builds hand-integrated mass-spring-damper simulations for grab-and-fling badge interactions.
    • Metal Shaders generates stitchable .colorEffect shaders for liquid chrome, holographic foil, and molten metal surfaces.
    • Canvas Masks delivers complex scratch-to-reveal coupon flows and high-performance metaball extrusion effects.
    • Native Scroll Drivers uses invisible UIScrollView delegates to achieve true momentum-aware paging for custom card stacks.

    How it works

    1. Define the motion by describing the feel, such as "snappy," "stretchy," or "molten."
    2. Specify the archetype like a Gesture Card, Liquid Toggle, or Hero-Zoom Context Menu.
    3. Verify the intent log to see how designer vocabulary is mapped to specific SwiftUI physics presets.
    4. Deploy the code directly to your project with automatic .xcodeproj registration and pbxproj updating.

    Frameworks & tools

    SwiftUI, CoreHaptics, SceneKit, Metal Shaders (MSL), and WidgetKit for Dynamic Island activities.

    Why this beats prompting it yourself

    Standard LLMs struggle with the specific physics constants and coordinate space math required for fluid hero morphs. This skill applies a rigid Defaults Contract and Haptic Ladder, ensuring your animations never skip a frame or fire redundant buzzes.

    Use cases

    • Building a Telegram-style reaction menu with fly-in animated GIF trays.
    • Creating a Photos-style hero-zoom context menu that respects real image aspect ratios.
    • Implementing an AI status glyph that morphs through a hinge dot rather than cross-fading.
    • Designing a high-performance Apple Fitness-style ring gauge with wrap-around shadow cues.

    Known limitations

    Requires iOS 17+ for most symbol effects. iOS 26 features like GlassEffectContainer require the latest SDK. Metal shaders need a physical device for accurate performance testing.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Mobile Development.

    Requires iOS 17+. iOS 26 features require the latest SDK. Metal shaders require physical device testing. Complex SceneKit embeds need manual .usdz asset handling for high-fidelity textures.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Software
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed1 month ago
    Updated19 days ago

    What's inside

    Frequently Asked Questions

    This skill generates high-fidelity, compilable SwiftUI code for complex physics-based gestures and liquid morphing effects that standard LLMs typically struggle to calculate accurately.

    The skill is optimized for iOS 17+, with specific support for the iOS 26 Liquid Glass API and Metal-based shaders that require the latest Apple SDKs.

    Yes, it includes automatic .xcodeproj registration and pbxproj updating to ensure the generated components are instantly integrated into your development environment.

    You receive production-ready Swift files, custom Metal shaders (.metal), and pre-configured HapticFeedback profiles designed to work seamlessly together.

    While it uses high-performance Metal shaders and Canvas masks, the code is optimized to follow Apple's Human Interface Guidelines to ensure fluid 120Hz performance on ProMotion displays.

    New in Mobile Development