diff --git a/Example/HostingExample/ViewController.swift b/Example/HostingExample/ViewController.swift
index 4d1b146b3..2b0c6f233 100644
--- a/Example/HostingExample/ViewController.swift
+++ b/Example/HostingExample/ViewController.swift
@@ -66,6 +66,6 @@ class ViewController: NSViewController {
 
 struct ContentView: View {
     var body: some View {
-        AnimatedColorTimelineView()
+        ToggleExample()
     }
 }
diff --git a/Example/SharedExample/View/ToggleExample.swift b/Example/SharedExample/View/ToggleExample.swift
new file mode 100644
index 000000000..c28e28922
--- /dev/null
+++ b/Example/SharedExample/View/ToggleExample.swift
@@ -0,0 +1,25 @@
+//
+//  ToggleExample.swift
+//  SharedExample
+
+#if OPENSWIFTUI
+import OpenSwiftUI
+#else
+import SwiftUI
+#endif
+
+struct ToggleExample: View {
+    // FIXME: Fix Representable update logic and add test case
+    @State var toggle = false
+    
+    var body: some View {
+        Toggle(isOn: $toggle) {
+            Color.red
+        }
+        .onAppear {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+                toggle.toggle()
+            }
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/Integration/Representable/Platform/PlatformViewCoordinator.swift b/Sources/OpenSwiftUI/Integration/Representable/Platform/PlatformViewCoordinator.swift
index 251fdaaf2..1034dfad4 100644
--- a/Sources/OpenSwiftUI/Integration/Representable/Platform/PlatformViewCoordinator.swift
+++ b/Sources/OpenSwiftUI/Integration/Representable/Platform/PlatformViewCoordinator.swift
@@ -13,6 +13,16 @@ import OpenSwiftUICore
 #if canImport(Darwin)
 @objc
 #endif
-class PlatformViewCoordinator: NSObject {}
-
-// TODO: weakDispatchUpdate
+class PlatformViewCoordinator: NSObject {
+    var weakDispatchUpdate: (() -> Void) -> Void {
+        { [weak self] update in
+            guard let self else {
+                update()
+                return
+            }
+            Update.dispatchImmediately { // FIXME: reason: nil
+                update()
+            }
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Toggle/Switch.swift b/Sources/OpenSwiftUI/View/Toggle/Switch.swift
deleted file mode 100644
index 8477e928b..000000000
--- a/Sources/OpenSwiftUI/View/Toggle/Switch.swift
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-//  Switch.swift
-//  OpenSwiftUI
-//
-//  Audited for iOS 15.5
-//  Status: Blocked by Color
-//  ID: 1246D37251EA3A918B392E2B95F8B7EF
-
-#if os(iOS) || os(visionOS)
-import UIKit
-
-private struct Switch: UIViewRepresentable {
-    typealias UIViewType = UISwitch
-    typealias Coordinator = PlatformSwitchCoordinator
-    
-    @Binding var isOn: Bool
-    var tint: Color?
-    
-    func makeUIView(context: Context) -> UISwitch {
-        let view = UISwitch()
-        view.addTarget(
-            context.coordinator,
-            action: #selector(PlatformSwitchCoordinator.isOnChanged),
-            for: .valueChanged
-        )
-        return view
-    }
-    
-    func updateUIView(_ uiView: UISwitch, context: Context) {
-        let isOn = isOn
-        let animated: Bool
-        if let _ = context.transaction.animation, !context.transaction.disablesAnimations {
-            animated = true
-        } else {
-            animated = false
-        }
-        uiView.setOn(isOn, animated: animated)
-        uiView.preferredStyle = .sliding
-        
-        let color: UIColor?
-        if let _ = tint {
-            // TODO: Resolve the color from the environment
-            color = nil
-        } else {
-            color = nil
-        }
-        let onTintColor = uiView.onTintColor
-        if let color {
-            if onTintColor == nil || color != onTintColor {
-                uiView.onTintColor = color
-            }
-        } else {
-            if onTintColor != nil {
-                uiView.onTintColor = nil
-            }
-        }
-        context.coordinator._isOn = _isOn
-    }
-    
-    func makeCoordinator() -> Coordinator {
-        PlatformSwitchCoordinator(isOn: _isOn)
-    }
-    
-}
-
-private class PlatformSwitchCoordinator: PlatformViewCoordinator {
-    var _isOn: Binding<Bool>
-    
-    init(isOn: Binding<Bool>) {
-        _isOn = isOn
-        super.init()
-    }
-
-    @objc
-    func isOnChanged(_ sender: UISwitch) {
-        Update.dispatchImmediately {
-            _isOn.wrappedValue = sender.isOn
-        }
-        sender.setOn(_isOn.wrappedValue, animated: true)
-    }
-}
-
-#endif
diff --git a/Sources/OpenSwiftUI/View/Toggle/SwitchToggleStyle.swift b/Sources/OpenSwiftUI/View/Toggle/SwitchToggleStyle.swift
new file mode 100644
index 000000000..584c1ae6b
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Toggle/SwitchToggleStyle.swift
@@ -0,0 +1,263 @@
+//
+//  SwitchToggleStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for iOS 6.5.4
+//  Status: WIP
+//  ID: 1246D37251EA3A918B392E2B95F8B7EF (SwiftUI)
+
+@_spi(Private)
+import OpenSwiftUICore
+
+// MARK: - SwitchToggleStyle [WIP]
+
+extension ToggleStyle where Self == SwitchToggleStyle {
+    @_alwaysEmitIntoClient
+    @MainActor
+    @preconcurrency
+    public static var `switch`: SwitchToggleStyle {
+        .init()
+    }
+}
+
+/// A toggle style that displays a leading label and a trailing switch.
+///
+/// Use the ``ToggleStyle/switch`` static variable to create this style:
+///
+///     Toggle("Enhance Sound", isOn: $isEnhanced)
+///         .toggleStyle(.switch)
+///
+@available(OpenSwiftUI_v1_0, *)
+public struct SwitchToggleStyle: ToggleStyle {
+    @Environment(\.controlSize)
+    private var controlSize: ControlSize
+
+    @Environment(\.tintColor)
+    private var controlTint: Color?
+
+    #if os(iOS) || os(visionOS)
+    @Environment(\.placementTint)
+    private var placementTint: [TintPlacement: AnyShapeStyle]
+    #endif
+
+    @Environment(\.effectiveFont)
+    private var font: Font
+
+    private let tint: Color?
+
+    /// Creates a switch toggle style.
+    ///
+    /// Don't call this initializer directly. Instead, use the
+    /// ``ToggleStyle/switch`` static variable to create this style:
+    ///
+    ///     Toggle("Enhance Sound", isOn: $isEnhanced)
+    ///         .toggleStyle(.switch)
+    ///
+    public init() {
+        tint = nil
+    }
+
+    /// Creates a switch style with a tint color.
+    @available(OpenSwiftUI_v2_0, *)
+    @available(*, deprecated, message: "Use ``View/tint(_)`` instead.")
+    @available(tvOS, unavailable)
+    public init(tint: Color) {
+        self.tint = tint
+    }
+
+    // FIXME
+    public func makeBody(configuration: Configuration) -> some View {
+        #if os(iOS) || os(visionOS)
+        Switch(_isOn: configuration.$isOn, tint: tint, thumbTint: placementTint[.switchThumb], font: font)
+            .fixedSize()
+            // .contentShape(Capsule())
+            // .accessibilityLabel
+            // .gesture
+        #elseif os(macOS)
+        Switch(_isOn: configuration.$isOn, tint: tint, font: font, _acceptsFirstMouse: .init(\.acceptsFirstMouse))
+            .fixedSize()
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+}
+
+@available(*, unavailable)
+extension SwitchToggleStyle: Sendable {}
+
+#if os(iOS) || os(visionOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
+
+// MARK: - Switch
+
+#if os(iOS) || os(visionOS)
+typealias PlatformSwitch = UISwitch
+
+private struct Switch: UIViewRepresentable {
+    var _isOn: Binding<Bool>
+    var tint: Color?
+    var thumbTint: AnyShapeStyle?
+    var font: Font
+
+    func makeUIView(context: Context) -> PlatformSwitch {
+        let view = PlatformSwitch()
+        view.addTarget(
+            context.coordinator,
+            action: #selector(PlatformSwitchCoordinator.isOnChanged),
+            for: .valueChanged
+        )
+        return view
+    }
+
+    func updateUIView(_ uiView: PlatformSwitch, context: Context) {
+        let isOn = _isOn.wrappedValue
+        let transaction = context.transaction
+        Update.enqueueAction(reason: nil) { [transaction] in
+            uiView.setOn(isOn, animated: transaction.disablesAnimations)
+        }
+        uiView.preferredStyle = .sliding
+        let newTintColor: UIColor? = if let tint {
+            (tint.resolve(in: context.environment).kitColor as! UIColor)
+        } else {
+            nil
+        }
+        if newTintColor != uiView.onTintColor {
+            uiView.onTintColor = newTintColor
+        }
+        if let thumbTint, let thumbColor = thumbTint.fallbackColor(in: context.environment) {
+            let newThumbColor = thumbColor.resolve(in: context.environment).kitColor as! UIColor
+            if newThumbColor != uiView.thumbTintColor {
+                uiView.thumbTintColor = newThumbColor
+            }
+        }
+        context.coordinator._isOn = _isOn
+    }
+    func makeCoordinator() -> PlatformSwitchCoordinator {
+        PlatformSwitchCoordinator(isOn: _isOn)
+    }
+}
+#elseif os(macOS)
+// FIXME
+protocol AcceptsFirstMouseCustomizing {
+    var customAcceptsFirstMouse: Bool? { get }
+}
+
+extension AcceptsFirstMouseCustomizing {
+    var effectiveAcceptsFirstMouse: Bool? {
+        // FIXME: Find via view hierarchy if not set directly
+        customAcceptsFirstMouse
+    }
+}
+
+extension EnvironmentValues {
+    var acceptsFirstMouse: Bool? {
+        // FIXME
+        get { controlSize == .mini }
+    }
+}
+
+private final class PlatformSwitch: NSSwitch, AcceptsFirstMouseCustomizing {
+    var customAcceptsFirstMouse: Bool?
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        if ResponderBasedHitTesting.enabled {
+            customAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        } else {
+            effectiveAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        }
+    }
+}
+
+private struct Switch: NSViewRepresentable {
+    var _isOn: Binding<Bool>
+    var tint: Color?
+    var font: Font
+    var _acceptsFirstMouse: Environment<Bool?>
+
+    func makeNSView(context: Context) -> PlatformSwitch {
+        let view = PlatformSwitch()
+        view.target = context.coordinator
+        return view
+    }
+
+    func updateNSView(_ nsView: PlatformSwitch, context: Context) {
+        let isOn = _isOn.wrappedValue
+        if context.transaction.disablesAnimations {
+            nsView.state = isOn ? .on : .off
+        } else {
+            nsView.animator().state = isOn ? .on : .off
+        }
+        context.coordinator._isOn = _isOn
+        nsView.font = font.platformFont(in: context.environment)
+        if let superview = nsView.superview {
+            let appearance = superview.effectiveAppearance
+            nsView.appearance = if let tint, tint != Color.accent {
+                appearance.applyingTintColor(.init(tint))
+            } else {
+                nil
+            }
+        }
+        nsView.customAcceptsFirstMouse = _acceptsFirstMouse.wrappedValue
+    }
+
+    func makeCoordinator() -> PlatformSwitchCoordinator {
+        PlatformSwitchCoordinator(isOn: _isOn)
+    }
+}
+#endif
+
+
+// MARK: - PlatformSwitchCoordinator
+
+#if os(iOS) || os(visionOS)
+private class PlatformSwitchCoordinator: PlatformViewCoordinator {
+    var _isOn: Binding<Bool>
+
+    var isOn: Bool {
+        get { _isOn.wrappedValue }
+        set { _isOn.wrappedValue = newValue }
+    }
+
+    init(isOn: Binding<Bool>) {
+        _isOn = isOn
+        super.init()
+    }
+
+    @objc
+    func isOnChanged(_ sender: UISwitch) {
+        weakDispatchUpdate {
+            isOn = sender.isOn
+        }
+        sender.setOn(isOn, animated: !_isOn.transaction.disablesAnimations)
+    }
+}
+#elseif os(macOS)
+private class PlatformSwitchCoordinator: PlatformViewCoordinator {
+    var _isOn: Binding<Bool>
+
+    var isOn: Bool {
+        get { _isOn.wrappedValue }
+        set { _isOn.wrappedValue = newValue }
+    }
+
+    init(isOn: Binding<Bool>) {
+        _isOn = isOn
+        super.init()
+    }
+
+    @objc
+    func isOnChanged(_ sender: NSSwitch) {
+        weakDispatchUpdate {
+            isOn = sender.state == .on
+        }
+        if _isOn.transaction.disablesAnimations {
+            sender.state = isOn ? .on : .off
+        } else {
+            sender.animator().state = isOn ? .on : .off
+        }
+    }
+}
+#endif
diff --git a/Sources/OpenSwiftUI/View/Toggle/Toggle.swift b/Sources/OpenSwiftUI/View/Toggle/Toggle.swift
new file mode 100644
index 000000000..88859d533
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Toggle/Toggle.swift
@@ -0,0 +1,79 @@
+//
+//  Toggle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+
+import OpenSwiftUICore
+
+// MARK: - Toggle [WIP]
+
+@available(OpenSwiftUI_v1_0, *)
+public struct Toggle<Label>: View where Label: View {
+    @Binding var toggleState: ToggleState
+
+    var label: Label
+
+    // var appIntentAction: AppIntentAction?
+
+    public init(
+        isOn: Binding<Bool>,
+        @ViewBuilder label: () -> Label
+    ) {
+        self.init(toggledOn: [isOn], label: label)
+    }
+
+    @_spi(_)
+    @available(OpenSwiftUI_v4_0, *)
+    @available(*, deprecated, message: "Use Toggle.init(sources:isOn:label:).")
+    public init<C>(
+        isOn: C,
+        @ViewBuilder label: () -> Label
+    ) where C: RandomAccessCollection, C.Element == Binding<Bool> {
+        self.init(toggledOn: isOn, label: label)
+    }
+
+    @available(OpenSwiftUI_v3_0, *)
+    public init<C>(
+        sources: C,
+        isOn: KeyPath<C.Element, Binding<Bool>>,
+        @ViewBuilder label: () -> Label
+    ) where C: RandomAccessCollection {
+        self.init(toggledOn: sources.lazy.map { $0[keyPath: isOn] }, label: label)
+    }
+
+    init<C>(
+        toggledOn: C,
+        @ViewBuilder label: () -> Label
+    ) where C: Collection, C.Element == Binding<Bool> {
+        self.label = label()
+        _toggleState = Binding(get: {
+            ToggleState.stateFor(item: true, in: toggledOn)
+        }, set: { value in
+            for binding in toggledOn {
+                binding.wrappedValue = (value == .on)
+            }
+        })
+    }
+
+    public var body: some View {
+        // FIXME
+        ResolvedToggleStyle(
+            configuration: ToggleStyleConfiguration(
+                label: .init(),
+                isOn: $toggleState.projecting(ToggleStateBool()),
+                toggleState: $toggleState,
+                isMixed: false,
+                effect: .binding // FIXME
+            )
+        ).viewAlias(ToggleStyleConfiguration.Label.self) {
+            label
+        }
+    }
+}
+
+@available(*, unavailable)
+extension Toggle: Sendable {}
+
+// TODO: Toggle + Extension
diff --git a/Sources/OpenSwiftUI/View/Toggle/ToggleStyle.swift b/Sources/OpenSwiftUI/View/Toggle/ToggleStyle.swift
new file mode 100644
index 000000000..a0b4b43a4
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Toggle/ToggleStyle.swift
@@ -0,0 +1,465 @@
+//
+//  ToggleStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Blocked by ArchivedView
+//  ID: FB08626C1326F7E32DC674FF8C676196 (SwiftUI)
+
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - ToggleStyle
+
+/// The appearance and behavior of a toggle.
+///
+/// To configure the style for a single ``Toggle`` or for all toggle instances
+/// in a view hierarchy, use the ``View/toggleStyle(_:)`` modifier. You can
+/// specify one of the built-in toggle styles, like ``ToggleStyle/switch`` or
+/// ``ToggleStyle/button``:
+///
+///     Toggle(isOn: $isFlagged) {
+///         Label("Flag", systemImage: "flag.fill")
+///     }
+///     .toggleStyle(.button)
+///
+/// Alternatively, you can create and apply a custom style.
+///
+/// ### Custom styles
+///
+/// To create a custom style, declare a type that conforms to the `ToggleStyle`
+/// protocol and implement the required ``ToggleStyle/makeBody(configuration:)``
+/// method. For example, you can define a checklist toggle style:
+///
+///     struct ChecklistToggleStyle: ToggleStyle {
+///         func makeBody(configuration: Configuration) -> some View {
+///             // Return a view that has checklist appearance and behavior.
+///         }
+///     }
+///
+/// Inside the method, use the `configuration` parameter, which is an instance
+/// of the ``ToggleStyleConfiguration`` structure, to get the label and
+/// a binding to the toggle state. To see examples of how to use these items
+/// to construct a view that has the appearance and behavior of a toggle, see
+/// ``ToggleStyle/makeBody(configuration:)``.
+///
+/// To provide easy access to the new style, declare a corresponding static
+/// variable in an extension to `ToggleStyle`:
+///
+///     extension ToggleStyle where Self == ChecklistToggleStyle {
+///         static var checklist: ChecklistToggleStyle { .init() }
+///     }
+///
+/// You can then use your custom style:
+///
+///     Toggle(activity.name, isOn: $activity.isComplete)
+///         .toggleStyle(.checklist)
+///
+/// A type conforming to this protocol inherits `@preconcurrency @MainActor`
+/// isolation from the protocol if the conformance is included in the type's
+/// base declaration:
+///
+///     struct MyCustomType: Transition {
+///         // `@preconcurrency @MainActor` isolation by default
+///     }
+///
+/// Isolation to the main actor is the default, but it's not required. Declare
+/// the conformance in an extension to opt out of main actor isolation:
+///
+///     extension MyCustomType: Transition {
+///         // `nonisolated` by default
+///     }
+///
+@available(OpenSwiftUI_v1_0, *)
+@MainActor
+@preconcurrency
+public protocol ToggleStyle {
+
+    /// A view that represents the appearance and interaction of a toggle.
+    ///
+    /// OpenSwiftUI infers this type automatically based on the ``View``
+    /// instance that you return from your implementation of the
+    /// ``makeBody(configuration:)`` method.
+    associatedtype Body: View
+
+    /// Creates a view that represents the body of a toggle.
+    ///
+    /// Implement this method when you define a custom toggle style that
+    /// conforms to the ``ToggleStyle`` protocol. Use the `configuration`
+    /// input --- a ``ToggleStyleConfiguration`` instance --- to access the
+    /// toggle's label and state. Return a view that has the appearance and
+    /// behavior of a toggle. For example you can create a toggle that displays
+    /// a label and a circle that's either empty or filled with a checkmark:
+    ///
+    ///     struct ChecklistToggleStyle: ToggleStyle {
+    ///         func makeBody(configuration: Configuration) -> some View {
+    ///             Button {
+    ///                 configuration.isOn.toggle()
+    ///             } label: {
+    ///                 HStack {
+    ///                     Image(systemName: configuration.isOn
+    ///                             ? "checkmark.circle.fill"
+    ///                             : "circle")
+    ///                     configuration.label
+    ///                 }
+    ///             }
+    ///             .tint(.primary)
+    ///             .buttonStyle(.borderless)
+    ///         }
+    ///     }
+    ///
+    /// The `ChecklistToggleStyle` toggle style provides a way to both observe
+    /// and modify the toggle state: the circle fills for the on state, and
+    /// users can tap or click the toggle to change the state. By using a
+    /// customized ``Button`` to compose the toggle's body, OpenSwiftUI
+    /// automatically provides the behaviors that users expect from a
+    /// control that has button-like characteristics.
+    ///
+    /// You can present a collection of toggles that use this style in a stack:
+    ///
+    /// ![A screenshot of three items stacked vertically. All have a circle
+    /// followed by a label. The first has the label Walk the dog, and the
+    /// circle is filled. The second has the label Buy groceries, and the
+    /// circle is filled. The third has the label Call Mom, and the cirlce is
+    /// empty.](ToggleStyle-makeBody-1-iOS)
+    ///
+    /// When updating a view hierarchy, the system calls your implementation
+    /// of the `makeBody(configuration:)` method for each ``Toggle`` instance
+    /// that uses the associated style.
+    ///
+    /// ### Modify the current style
+    ///
+    /// Rather than create an entirely new style, you can alternatively
+    /// modify a toggle's current style. Use the ``Toggle/init(_:)``
+    /// initializer inside the `makeBody(configuration:)` method to create
+    /// and modify a toggle based on a `configuration` value. For example,
+    /// you can create a style that adds padding and a red border to the
+    /// current style:
+    ///
+    ///     struct RedBorderToggleStyle: ToggleStyle {
+    ///         func makeBody(configuration: Configuration) -> some View {
+    ///             Toggle(configuration)
+    ///                 .padding()
+    ///                 .border(.red)
+    ///         }
+    ///     }
+    ///
+    /// If you create a `redBorder` static variable from this style,
+    /// you can apply the style to toggles that already use another style, like
+    /// the built-in ``ToggleStyle/switch`` and ``ToggleStyle/button`` styles:
+    ///
+    ///     Toggle("Switch", isOn: $isSwitchOn)
+    ///         .toggleStyle(.redBorder)
+    ///         .toggleStyle(.switch)
+    ///
+    ///     Toggle("Button", isOn: $isButtonOn)
+    ///         .toggleStyle(.redBorder)
+    ///         .toggleStyle(.button)
+    ///
+    /// Both toggles appear with the usual styling, each with a red border:
+    ///
+    /// ![A screenshot of a switch toggle with a red border, and a button
+    /// toggle with a red border.](ToggleStyle-makeBody-2-iOS)
+    ///
+    /// Apply the custom style closer to the toggle than the
+    /// modified style because OpenSwiftUI evaluates style view modifiers in order
+    /// from outermost to innermost. If you apply the styles in the other
+    /// order, the red border style doesn't have an effect, because the
+    /// built-in styles override it completely.
+    ///
+    /// - Parameter configuration: The properties of the toggle, including a
+    ///   label and a binding to the toggle's state.
+    /// - Returns: A view that has behavior and appearance that enables it
+    ///   to function as a ``Toggle``.
+    @ViewBuilder
+    func makeBody(configuration: Configuration) -> Self.Body
+
+    /// The properties of a toggle instance.
+    ///
+    /// You receive a `configuration` parameter of this type --- which is an
+    /// alias for the ``ToggleStyleConfiguration`` type --- when you implement
+    /// the required ``makeBody(configuration:)`` method in a custom toggle
+    /// style implementation.
+    typealias Configuration = ToggleStyleConfiguration
+}
+
+// MARK: - ToggleStyleConfiguration [WIP]
+
+/// The properties of a toggle instance.
+///
+/// When you define a custom toggle style by creating a type that conforms to
+/// the ``ToggleStyle`` protocol, you implement the
+/// ``ToggleStyle/makeBody(configuration:)`` method. That method takes a
+/// `ToggleStyleConfiguration` input that has the information you need
+/// to define the behavior and appearance of a ``Toggle``.
+///
+/// The configuration structure's ``label-swift.property`` reflects the
+/// toggle's content, which might be the value that you supply to the
+/// `label` parameter of the ``Toggle/init(isOn:label:)`` initializer.
+/// Alternatively, it could be another view that OpenSwiftUI builds from an
+/// initializer that takes a string input, like ``Toggle/init(_:isOn:)``.
+/// In either case, incorporate the label into the toggle's view to help
+/// the user understand what the toggle does. For example, the built-in
+/// ``ToggleStyle/switch`` style horizontally stacks the label with the
+/// control element.
+///
+/// The structure's ``isOn`` property provides a ``Binding`` to the state
+/// of the toggle. Adjust the appearance of the toggle based on this value.
+/// For example, the built-in ``ToggleStyle/button`` style fills the button's
+/// background when the property is `true`, but leaves the background empty
+/// when the property is `false`. Change the value when the user performs
+/// an action that's meant to change the toggle, like the button does when
+/// tapped or clicked by the user.
+public struct ToggleStyleConfiguration {
+    /// A type-erased label of a toggle.
+    ///
+    /// OpenSwiftUI provides a value of this type --- which is a ``View`` type ---
+    /// as the ``label-swift.property`` to your custom toggle style
+    /// implementation. Use the label to help define the appearance of the
+    /// toggle.
+    public struct Label: ViewAlias {
+        nonisolated init() {}
+    }
+
+    /// A view that describes the effect of switching the toggle between states.
+    ///
+    /// Use this value in your implementation of the
+    /// ``ToggleStyle/makeBody(configuration:)`` method when defining a custom
+    /// ``ToggleStyle``. Access it through the that method's `configuration`
+    /// parameter.
+    ///
+    /// Because the label is a ``View``, you can incorporate it into the
+    /// view hierarchy that you return from your style definition. For example,
+    /// you can combine the label with a circle image in an ``HStack``:
+    ///
+    ///     HStack {
+    ///         Image(systemName: configuration.isOn
+    ///             ? "checkmark.circle.fill"
+    ///             : "circle")
+    ///         configuration.label
+    ///     }
+    ///
+    public let label: ToggleStyleConfiguration.Label
+
+    /// A binding to a state property that indicates whether the toggle is on.
+    ///
+    /// Because this value is a ``Binding``, you can both read and write it
+    /// in your implementation of the ``ToggleStyle/makeBody(configuration:)``
+    /// method when defining a custom ``ToggleStyle``. Access it through
+    /// that method's `configuration` parameter.
+    ///
+    /// Read this value to set the appearance of the toggle. For example, you
+    /// can choose between empty and filled circles based on the `isOn` value:
+    ///
+    ///     Image(systemName: configuration.isOn
+    ///         ? "checkmark.circle.fill"
+    ///         : "circle")
+    ///
+    /// Write this value when the user takes an action that's meant to change
+    /// the state of the toggle. For example, you can toggle it inside the
+    /// `action` closure of a ``Button`` instance:
+    ///
+    ///     Button {
+    ///         configuration.isOn.toggle()
+    ///     } label: {
+    ///         // Draw the toggle.
+    ///     }
+    ///
+    @Binding
+    public var isOn: Bool
+
+    @Binding
+    private var toggleState: ToggleState
+
+    /// Whether the ``Toggle`` is currently in a mixed state.
+    ///
+    /// Use this property to determine whether the toggle style should render
+    /// a mixed state presentation. A mixed state corresponds to an underlying
+    /// collection with a mix of true and false Bindings.
+    /// To toggle the state, use the ``Bool.toggle()`` method on the ``isOn``
+    /// binding.
+    ///
+    /// In the following example, a custom style uses the `isMixed` property
+    /// to render the correct toggle state using symbols:
+    ///
+    ///     struct SymbolToggleStyle: ToggleStyle {
+    ///         func makeBody(configuration: Configuration) -> some View {
+    ///             Button {
+    ///                 configuration.isOn.toggle()
+    ///             } label: {
+    ///                 Image(
+    ///                     systemName: configuration.isMixed
+    ///                     ? "minus.circle.fill" : configuration.isOn
+    ///                     ? "checkmark.circle.fill" : "circle.fill")
+    ///                 configuration.label
+    ///             }
+    ///         }
+    ///     }
+    @available(OpenSwiftUI_v4_0, *)
+    public var isMixed: Bool
+
+    enum Effect {
+        // case appIntent(AppIntentAction)
+        case binding
+    }
+
+    var effect: Effect
+
+    init(
+        label: ToggleStyleConfiguration.Label,
+        isOn: Binding<Bool>,
+        toggleState: Binding<ToggleState>,
+        isMixed: Bool,
+        effect: Effect
+    ) {
+        self.label = label
+        self._isOn = isOn
+        self._toggleState = toggleState
+        self.isMixed = isMixed
+        self.effect = effect
+    }
+}
+
+@available(*, unavailable)
+extension ToggleStyleConfiguration: Sendable {}
+
+@available(*, unavailable)
+extension ToggleStyleConfiguration.Label: Sendable {}
+
+// MARK: - ToggleStateBool
+
+struct ToggleStateBool: Projection {
+    typealias Base = ToggleState
+
+    typealias Projected = Bool
+
+    func get(base: ToggleState) -> Bool {
+        base == .on
+    }
+
+    func set(base: inout ToggleState, newValue: Bool) {
+        base = newValue ? .on : .off
+    }
+}
+
+// MARK: - ResolvedToggleStyle [WIP]
+
+struct ResolvedToggleStyle: StyleableView {
+    var configuration: ToggleStyleConfiguration
+
+    // FIXME: body: ResolvedToggleStyleBody
+
+    static var defaultStyleModifier = ToggleStyleModifier(style: .switch)
+}
+
+// MARK: - ToggleStyleModifier
+
+struct ToggleStyleModifier<Style>: StyleModifier where Style: ToggleStyle {
+    init(style: Style) {
+        self.style = style
+    }
+
+    var style: Style
+
+    func styleBody(configuration: Style.Configuration) -> Style.Body {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+extension View {
+    /// Sets the style for toggles in a view hierarchy.
+    ///
+    /// Use this modifier on a ``Toggle`` instance to set a style that defines
+    /// the control's appearance and behavior. For example, you can choose
+    /// the ``ToggleStyle/switch`` style:
+    ///
+    ///     Toggle("Vibrate on Ring", isOn: $vibrateOnRing)
+    ///         .toggleStyle(.switch)
+    ///
+    /// Built-in styles typically have a similar appearance across platforms,
+    /// tailored to the platform's overall style:
+    ///
+    /// | Platform    | Appearance |
+    /// |-------------|------------|
+    /// | iOS, iPadOS | ![A screenshot of the text Vibrate on Ring appearing to the left of a toggle switch that's on. The toggle's tint color is green. The toggle and its text appear in a rounded rectangle.](View-toggleStyle-1-iOS) |
+    /// | macOS       | ![A screenshot of the text Vibrate on Ring appearing to the left of a toggle switch that's on. The toggle's tint color is blue. The toggle and its text appear on a neutral background.](View-toggleStyle-1-macOS) |
+    ///
+    /// ### Styling toggles in a hierarchy
+    ///
+    /// You can set a style for all toggle instances within a view hierarchy
+    /// by applying the style modifier to a container view. For example, you
+    /// can apply the ``ToggleStyle/button`` style to an ``HStack``:
+    ///
+    ///     HStack {
+    ///         Toggle(isOn: $isFlagged) {
+    ///             Label("Flag", systemImage: "flag.fill")
+    ///         }
+    ///         Toggle(isOn: $isMuted) {
+    ///             Label("Mute", systemImage: "speaker.slash.fill")
+    ///         }
+    ///     }
+    ///     .toggleStyle(.button)
+    ///
+    /// The example above has the following appearance when `isFlagged` is
+    /// `true` and `isMuted` is `false`:
+    ///
+    /// | Platform    | Appearance |
+    /// |-------------|------------|
+    /// | iOS, iPadOS | ![A screenshot of two buttons arranged horizontally. The first has the image of a flag and is active with a blue tint. The second has an image of a speaker with a line through it and is inactive with a neutral tint.](View-toggleStyle-2-iOS) |
+    /// | macOS       | ![A screenshot of two buttons arranged horizontally. The first has the image of a flag and is active with a blue tint. The second has an image of a speaker with a line through it and is inactive with a neutral tint.](View-toggleStyle-2-macOS) |
+    ///
+    /// ### Automatic styling
+    ///
+    /// If you don't set a style, OpenSwiftUI assumes a value of
+    /// ``ToggleStyle/automatic``, which corresponds to a context-specific
+    /// default. Specify the automatic style explicitly to override a
+    /// container's style and revert to the default:
+    ///
+    ///     HStack {
+    ///         Toggle(isOn: $isShuffling) {
+    ///             Label("Shuffle", systemImage: "shuffle")
+    ///         }
+    ///         Toggle(isOn: $isRepeating) {
+    ///             Label("Repeat", systemImage: "repeat")
+    ///         }
+    ///
+    ///         Divider()
+    ///
+    ///         Toggle("Enhance Sound", isOn: $isEnhanced)
+    ///             .toggleStyle(.automatic) // Revert to the default style.
+    ///     }
+    ///     .toggleStyle(.button) // Use button style for toggles in the stack.
+    ///     .labelStyle(.iconOnly) // Omit the title from any labels.
+    ///
+    /// The style that OpenSwiftUI uses as the default depends on both the platform
+    /// and the context. In macOS, the default in most contexts is a
+    /// ``ToggleStyle/checkbox``, while in iOS, the default toggle style is a
+    /// ``ToggleStyle/switch``:
+    ///
+    /// | Platform    | Appearance |
+    /// |-------------|------------|
+    /// | iOS, iPadOS | ![A screenshot of several horizontally arranged items: two buttons, a vertical divider line, the text Enhance sound, and a switch. The first button has two right facing arrows that cross over in the middle and is active with a blue tint. The second button has one right and one left facing arrow and is inactive with neutral tint. The switch is on and has a green tint.](View-toggleStyle-3-iOS) |
+    /// | macOS       | ![A screenshot of several horizontally arranged items: two buttons, a vertical divider line, a checkbox, and the text Enhance sound. The first button has two right facing arrows that cross over in the middle and is active with a blue tint. The second button has one right and one left facing arrow and is inactive with a neutral tint. The check box is checked and has a blue tint.](View-toggleStyle-3-macOS) |
+    ///
+    /// > Note: Like toggle style does for toggles, the ``View/labelStyle(_:)``
+    /// modifier sets the style for ``Label`` instances in the hierarchy. The
+    /// example above demostrates the compact ``LabelStyle/iconOnly`` style,
+    /// which is useful for button toggles in space-constrained contexts.
+    /// Always include a descriptive title for better accessibility.
+    ///
+    /// For more information about how OpenSwiftUI chooses a default toggle style,
+    /// see the ``ToggleStyle/automatic`` style.
+    ///
+    /// - Parameter style: The toggle style to set. Use one of the built-in
+    ///   values, like ``ToggleStyle/switch`` or ``ToggleStyle/button``,
+    ///   or a custom style that you define by creating a type that conforms
+    ///   to the ``ToggleStyle`` protocol.
+    ///
+    /// - Returns: A view that uses the specified toggle style for itself
+    ///   and its child views.
+    nonisolated public func toggleStyle<S>(_ style: S) -> some View where S: ToggleStyle {
+        modifier(ToggleStyleModifier(style: style))
+    }
+}
+
+// TODO: Toggle + Archive stuff
diff --git a/Sources/OpenSwiftUICore/Event/Responder/ResponderBasedHitTesting.swift b/Sources/OpenSwiftUICore/Event/Responder/ResponderBasedHitTesting.swift
new file mode 100644
index 000000000..7b24ba7e9
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Responder/ResponderBasedHitTesting.swift
@@ -0,0 +1,12 @@
+//
+//  ResponderBasedHitTesting.swift
+//  OpenSwiftUICore
+//
+//  ID: 4D506C1C4C6075F3B74E3FAB14E5B59E (SwiftUICore)
+
+package enum ResponderBasedHitTesting {
+    // FIXME
+    package static var enabled: Bool {
+        false
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Graphic/Color/AccentColor.swift b/Sources/OpenSwiftUICore/Graphic/Color/AccentColor.swift
new file mode 100644
index 000000000..023855027
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Graphic/Color/AccentColor.swift
@@ -0,0 +1,10 @@
+//
+//  AccentColor.swift
+//  OpenSwiftUICore
+//
+//  ID: AA5C9AAB6528C7C6B599DF55246DE53A (SwiftUICore)
+
+extension Color {
+    // FIXME
+    public static var accent: Color { .clear }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/Tint.swift b/Sources/OpenSwiftUICore/Shape/Tint.swift
new file mode 100644
index 000000000..abf018e77
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/Tint.swift
@@ -0,0 +1,177 @@
+//
+//  TintShape.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: EB037BD7690CB8A700384AACA7B075E4 (SwiftUICore)
+
+// MARK: - View + tint ShapeStyle
+
+@available(OpenSwiftUI_v4_0, *)
+extension View {
+    /// Sets the tint within this view.
+    ///
+    /// Use this method to override the default accent color for this view with
+    /// a given styling. Unlike an app's accent color, which can be
+    /// overridden by user preference, tint is always respected and should
+    /// be used as a way to provide additional meaning to the control.
+    ///
+    /// Controls which are unable to style themselves using the given type of
+    /// `ShapeStyle` will try to approximate the styling as best as they can
+    /// (i.e. controls which can not style themselves using a gradient will
+    /// attempt to use the color of the gradient's first stop).
+    ///
+    /// This example shows a linear gauge tinted with a
+    /// gradient from ``ShapeStyle/blue`` to ``ShapeStyle/red``.
+    ///
+    ///     struct ControlTint: View {
+    ///         var body: some View {
+    ///             Gauge(value: 75, in: 0...100) {
+    ///                 Text("Temperature")
+    ///             }
+    ///             .gaugeStyle(.linearCapacity)
+    ///             .tint(Gradient(colors: [.blue, .orange, .red]))
+    ///         }
+    ///     }
+    ///
+    /// Some controls adapt to the tint color differently based on their style,
+    /// the current platform, and the surrounding context. For example, in
+    /// macOS, a button with the ``PrimitiveButtonStyle/bordered`` style doesn't
+    /// tint its background, but one with the
+    /// ``PrimitiveButtonStyle/borderedProminent`` style does. In macOS, neither
+    /// of these button styles tint their label, but they do in other platforms.
+    ///
+    /// - Parameter tint: The tint to apply.
+    @inlinable
+    nonisolated public func tint<S>(_ tint: S?) -> some View where S: ShapeStyle {
+        environment(\.tint, tint.map(AnyShapeStyle.init))
+    }
+}
+
+// MARK: - TintPlacement
+
+@_spi(Private)
+@available(OpenSwiftUI_v6_0, *)
+public struct TintPlacement: Hashable {
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    public static var switchThumb: TintPlacement {
+        .init(guts: .switchThumb)
+    }
+
+    enum Guts {
+        case switchThumb
+    }
+
+    let guts: Guts
+}
+
+@_spi(Private)
+@available(*, unavailable)
+extension TintPlacement: Sendable {}
+
+// MARK: - View + tintPlacement
+
+@_spi(Private)
+@available(OpenSwiftUI_v6_0, *)
+extension View {
+    @inlinable
+    nonisolated public func tint<S>(_ tint: S?, for placement: TintPlacement) -> some View where S: ShapeStyle {
+        transformEnvironment(\.placementTint) { value in
+            if let tint {
+                value[placement] = .init(tint)
+            }
+        }
+    }
+}
+
+// MARK: - View + tint Color
+
+@available(OpenSwiftUI_v3_0, *)
+extension View {
+    /// Sets the tint color within this view.
+    ///
+    /// Use this method to override the default accent color for this view.
+    /// Unlike an app's accent color, which can be overridden by user
+    /// preference, the tint color is always respected and should be used as a
+    /// way to provide additional meaning to the control.
+    ///
+    /// This example shows Answer and Decline buttons with ``ShapeStyle/green``
+    /// and ``ShapeStyle/red`` tint colors, respectively.
+    ///
+    ///     struct ControlTint: View {
+    ///         var body: some View {
+    ///             HStack {
+    ///                 Button {
+    ///                     // Answer the call
+    ///                 } label: {
+    ///                     Label("Answer", systemImage: "phone")
+    ///                 }
+    ///                 .tint(.green)
+    ///                 Button {
+    ///                     // Decline the call
+    ///                 } label: {
+    ///                     Label("Decline", systemImage: "phone.down")
+    ///                 }
+    ///                 .tint(.red)
+    ///             }
+    ///             .buttonStyle(.borderedProminent)
+    ///             .padding()
+    ///         }
+    ///     }
+    ///
+    /// Some controls adapt to the tint color differently based on their style,
+    /// the current platform, and the surrounding context. For example, in
+    /// macOS, a button with the ``PrimitiveButtonStyle/bordered`` style doesn't
+    /// tint its background, but one with the
+    /// ``PrimitiveButtonStyle/borderedProminent`` style does. In macOS, neither
+    /// of these button styles tint their label, but they do in other platforms.
+    ///
+    /// - Parameter tint: The tint ``Color`` to apply.
+    @inlinable
+    @_disfavoredOverload
+    nonisolated public func tint(_ tint: Color?) -> some View {
+        environment(\.tintColor, tint)
+    }
+}
+
+// MARK: - EnvironmentValues + tint
+
+private struct TintKey: EnvironmentKey {
+    package static var defaultValue: AnyShapeStyle? { nil }
+}
+
+private struct PlacementTintKey: EnvironmentKey {
+    package static var defaultValue: [TintPlacement: AnyShapeStyle] { [:] }
+}
+
+extension EnvironmentValues {
+    @usableFromInline
+    package var tint: AnyShapeStyle? {
+        get { self[TintKey.self] }
+        set { self[TintKey.self] = newValue }
+    }
+
+    @_spi(Private)
+    @usableFromInline
+    package var placementTint: [TintPlacement: AnyShapeStyle] {
+        get { self[PlacementTintKey.self] }
+        set { self[PlacementTintKey.self] = newValue }
+    }
+}
+
+@available(OpenSwiftUI_v3_0, *)
+extension EnvironmentValues {
+    @usableFromInline
+    package var tintColor: Color? {
+        get { tint?.fallbackColor(in: self) }
+        set { tint = newValue.map { AnyShapeStyle($0) } }
+    }
+
+    package var resolvedTintColor: Color.Resolved {
+        (tintColor ?? .accent).resolve(in: self)
+    }
+}
+
+// MARK: - TintShapeStyle [TODO]
diff --git a/Sources/OpenSwiftUICore/View/Toggle/ToggleState.swift b/Sources/OpenSwiftUICore/View/Toggle/ToggleState.swift
new file mode 100644
index 000000000..7853adaba
--- /dev/null
+++ b/Sources/OpenSwiftUICore/View/Toggle/ToggleState.swift
@@ -0,0 +1,49 @@
+//
+//  ToggleState.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+package enum ToggleState: UInt {
+    case on
+    case off
+    case mixed
+
+    package init(_ isOn: Bool) {
+        self = isOn ? .on : .off
+    }
+
+    package mutating func toggle() {
+        self = self == .on ? .off : .on
+    }
+
+    package static func stateFor<T, C>(
+        item: T,
+        in collection: C
+    ) -> ToggleState where T: Equatable, C: Collection, C.Element == Binding<T> {
+        if collection.allSatisfy({ item == $0.wrappedValue }) {
+            return .on
+        } else if collection.allSatisfy({ item != $0.wrappedValue }) {
+            return .off
+        } else {
+            return .mixed
+        }
+    }
+}
+
+extension ToggleState: Codable {}
+
+extension ToggleState: CaseIterable {}
+
+extension ToggleState: StronglyHashable {}
+
+extension ToggleState: CustomDebugStringConvertible {
+    package var debugDescription: String {
+        switch self {
+        case .on: "on"
+        case .off: "off"
+        case .mixed: "mixed"
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI_SPI/Shims/AppKit/AppKit_Private.h b/Sources/OpenSwiftUI_SPI/Shims/AppKit/AppKit_Private.h
index 67ff290f3..b9a1d2234 100644
--- a/Sources/OpenSwiftUI_SPI/Shims/AppKit/AppKit_Private.h
+++ b/Sources/OpenSwiftUI_SPI/Shims/AppKit/AppKit_Private.h
@@ -30,6 +30,10 @@ typedef OPENSWIFTUI_ENUM(NSInteger, NSViewVibrantBlendingStyle) {
 - (void)_updateLayerGeometryFromView;
 @end
 
+@interface NSAppearance (OpenSwiftUI_SPI)
+- (nullable NSAppearance *)appearanceByApplyingTintColor:(NSColor *)tintColor;
+@end
+
 OPENSWIFTUI_ASSUME_NONNULL_END
 
 #endif /* __has_include(<AppKit/AppKit.h>) */