MirageKit

MirageKit supports three primary streaming modes:

• Window: Captures a single window using ScreenCaptureKit.
• App: Groups windows by bundle identifier and follows new windows as they spawn.
• Desktop: Mirrors a virtual display sized to the client for 1:1 pixel mapping.

For fine-grained control, use MirageEncoderConfiguration to adjust codec, frame rate, encoder quality, and bit depth. Clients can also request per-stream tweaks using MirageEncoderOverrides.

To connect to a host, use MirageClientService. Implement MirageClientDelegate to handle client-side events. Use connect(to:) with a LoomPeer to establish the connection, and requestWindowList() to discover available windows.

import MirageKitClient

@MainActor
final class ClientController: MirageClientDelegate {
    let client = MirageClientService()

    init() { client.delegate = self }

    func connect(to host: LoomPeer) async throws {
        try await client.connect(to: host)
        try await client.requestWindowList()
    }
}

There are two ways to render the stream in SwiftUI:

1. Low-level: MirageStreamViewRepresentable

Use this for manual control over input events and drawable metrics.

2. High-level: MirageStreamContentView

This is the recommended approach for most apps. When paired with a MirageClientSessionStore, it automatically handles input, focus, and resizing plumbing.

// High-level approach
let sessionStore = MirageClientSessionStore()
let client = MirageClientService(sessionStore: sessionStore)

MirageStreamContentView(
    session: session,
    sessionStore: sessionStore,
    clientService: client,
    isDesktopStream: false
)

Add MirageKit to your Swift project using the following package dependency. You can choose specific products based on your role (Host or Client):

• MirageKitClient: For connecting to a host, rendering the stream, and sending input.
• MirageKitHost: For capturing, encoding, and serving a Mac to clients.
• MirageKit: Shared types and protocols.
• MirageHostBootstrapRuntime: For pre-login and remote unlock support.

.package(url: "https://github.com/EthanLipnik/MirageKit.git", from: "1.0.5"),

To turn a Mac into a stream provider, use MirageHostService. Implement MirageHostDelegate to handle host-side events and call start() to begin serving the Mac.

import MirageKitHost

@MainActor
final class HostController: MirageHostDelegate {
    private let host = MirageHostService()

    init() { host.delegate = self }

    func start() async throws {
        try await host.start()
    }
}

MirageKit requires specific permissions to function:

macOS Host Requirements

• Screen Recording: Required for ScreenCaptureKit window/desktop capture.
• Accessibility: Required for input forwarding and window activation.

Network Discovery (Both Host and Client)

You must add Bonjour service support to your Info.plist to allow device discovery via local network:

<key>NSBonjourServices</key>
<array>
    <string>_miragekit._tcp</string>
</array>

<key>NSLocalNetworkUsageDescription</key>
<string>Discover and connect to nearby Mirage devices.</string>

Note: For App Store distribution, you must include the com.apple.developer.networking.multicast entitlement.

After running the cleanup script, use these commands to verify that the ColorSync services have settled and that the number of Mirage profiles has been reduced.

1. Check CPU usage: Use top to monitor colorsyncd and colorsync.displayservices.
2. Check profile count: Count the remaining Mirage Shared Display files in the system directory.

top -l 2 -o cpu -n 10 -stats pid,command,cpu,mem,time
ls /Library/ColorSync/Profiles/Displays | grep -c 'Mirage Shared Display'