From 6b37a72733ac80ace4b18af78fdf6b02c794e360 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Mon, 3 Nov 2025 10:11:17 +0900
Subject: [PATCH 01/18] update AvaloniaVersion to 11.3.8

---
 src/Directory.Build.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 5132d06f..afe47d4f 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <AvaloniaVersion>11.1.0</AvaloniaVersion>
+    <AvaloniaVersion>11.3.8</AvaloniaVersion>
     <FuncUIVersion>1.5.2</FuncUIVersion>
   </PropertyGroup>
 	

From af2334436e293a06cc38dd4ce9524c2b8ddc7e60 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Mon, 3 Nov 2025 18:51:39 +0900
Subject: [PATCH 02/18] [WIP] Add ResourceDictionary bindings.

---
 .../Avalonia.FuncUI.UnitTests.fsproj          |   1 +
 .../DSL/Base/ResourceDictionaryTests.fs       | 259 ++++++++++++++++++
 src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj    |   1 +
 .../DSL/Base/ResourceDictionary.fs            |  52 ++++
 4 files changed, 313 insertions(+)
 create mode 100644 src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
 create mode 100644 src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs

diff --git a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
index 2e550c8e..c63e31b0 100644
--- a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
+++ b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
@@ -16,6 +16,7 @@
     <Compile Include="VirtualDom\VirtualDom.ModuleTests.fs" />
     <Compile Include="VirtualDom\VirtualDom.DifferTests.fs" />
     <Compile Include="VirtualDom\VirtualDom.PatcherTests.fs" />
+    <Compile Include="DSL\Base\ResourceDictionaryTests.fs" />
     <Compile Include="DSL\Base\StyledElementTests.fs" />
     <Compile Include="State.fs" />
     <Compile Include="Program.fs" />
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
new file mode 100644
index 00000000..b1cc319d
--- /dev/null
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -0,0 +1,259 @@
+namespace Avalonia.FuncUI.UnitTests.DSL
+
+open Avalonia
+open Avalonia.Controls
+open global.Xunit
+
+module ResourceDictionaryTests =
+    open Avalonia.FuncUI.VirtualDom
+    open Avalonia.FuncUI.DSL
+    open Avalonia.FuncUI.Types
+    open Avalonia.FuncUI.VirtualDom
+
+    module private VirtualDom =
+        open Avalonia.FuncUI.Builder
+
+        let create<'t when 't :> AvaloniaObject> (view: IView<'t>) : 't = VirtualDom.createObject view :?> 't
+
+        let update<'t when 't :> AvaloniaObject> (target: 't) (last: IView<'t>) (next: IView<'t>) : unit =
+            let diff = Differ.diff (last, next)
+            Patcher.patch (target, diff)
+
+    module private Assert =
+        let containsKey (dict: ResourceDictionary) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, null)
+            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
+            value
+
+        let notContainsKey (dict: ResourceDictionary) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, null)
+            Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key}. Found value: {value}")
+
+        let containsKeyWithValueWith (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
+            let isFound, actualValue = dict.TryGetResource(key, null)
+            let expectedValue = box expectedValue
+
+            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
+            Assert.Equal(expectedValue, converter actualValue)
+
+        let containsKeyWithValue (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
+            containsKeyWithValueWith dict key expectedValue (fun o -> o :?> 'v)
+
+    module ``keyValue`` =
+
+
+        [<Fact>]
+        let ``can set`` () =
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+
+            let key = "myKey"
+            let value = "myValue"
+
+            Assert.notContainsKey target key
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, value) ]
+
+            VirtualDom.update target initView updatedView
+
+            Assert.containsKeyWithValue target key value
+
+            let revertedView = ResourceDictionary.create []
+            VirtualDom.update target updatedView revertedView
+
+            Assert.notContainsKey target key
+
+        [<Fact>]
+        let ``can set null value`` =
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+
+            let key = "myKey"
+            let value = null
+            Assert.notContainsKey target key
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, value = value) ]
+
+            VirtualDom.update target initView updatedView
+            Assert.containsKeyWithValue target key value
+
+            VirtualDom.update target updatedView initView
+            Assert.notContainsKey target key
+
+
+        [<Fact>]
+        let ``can update value`` () =
+            let key = "myKey"
+
+            let createView (value: obj) =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, value = value) ]
+
+            let createViewWithIView value =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, view = value) ]
+
+            let initialValue = "initialValue"
+            let initView = createView initialValue
+            let target = VirtualDom.create initView
+
+            Assert.containsKeyWithValue target key initialValue
+
+            List.fold
+                (fun lastView acc ->
+                    match acc with
+                    | Choice1Of2(nextValue: obj) ->
+                        let updatedView = createView nextValue
+                        VirtualDom.update target lastView updatedView
+                        Assert.containsKeyWithValue target key nextValue
+                        updatedView
+                    | Choice2Of2(nextValue, expected, converter) ->
+                        let updatedView = createViewWithIView nextValue
+                        VirtualDom.update target lastView updatedView
+                        Assert.containsKeyWithValueWith target key expected converter
+                        updatedView)
+                initView
+                [ Choice1Of2 42
+                  Choice1Of2 "a string"
+                  Choice1Of2 null
+                  Choice1Of2 3.14
+                  Choice2Of2(TextBlock.create [ TextBlock.text "Hello" ], "Hello", fun o -> (o :?> TextBlock).Text)
+                  Choice1Of2 true
+                  Choice1Of2(TextBox(Text = "Hello, World!"))
+                  Choice1Of2(ContentControl(Content = Button(Content = "Click Me"))) ]
+
+
+        [<Fact>]
+        let ``can update key`` () =
+            let initialKey = "initialKey"
+            let updatedKey = "updatedKey"
+            let value = "myValue"
+
+            let initView =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (initialKey, value) ]
+
+            let target = VirtualDom.create initView
+
+            Assert.containsKeyWithValue target initialKey value
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (updatedKey, value) ]
+
+            VirtualDom.update target initView updatedView
+
+            Assert.notContainsKey target initialKey
+            Assert.containsKeyWithValue target updatedKey value
+
+
+        [<Fact>]
+        let ``can set multiple`` () =
+            let key1 = "key1"
+            let value1 = "value1"
+            let updatedValue1 = "updatedValue1"
+            let key2 = typeof<Button>
+            let value2 = Styling.ControlTheme(key2)
+            let updatedValue2 = Styling.ControlTheme(key2)
+
+            let initView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.keyValue (key1, value1)
+                      ResourceDictionary.keyValue (key2, value2) ]
+
+            let target = VirtualDom.create initView
+
+            Assert.containsKeyWithValue target key1 value1
+            Assert.containsKeyWithValue target key2 value2
+
+            let updatedView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.keyValue (key1, updatedValue1)
+                      ResourceDictionary.keyValue (key2, updatedValue2) ]
+
+            VirtualDom.update target initView updatedView
+
+            Assert.containsKeyWithValue target key1 updatedValue1
+            Assert.containsKeyWithValue target key2 updatedValue2
+
+            let revertedView = ResourceDictionary.create []
+            VirtualDom.update target updatedView revertedView
+
+            Assert.notContainsKey target key1
+            Assert.notContainsKey target key2
+
+        [<Fact>]
+        let ``can set with IView`` () =
+            let assertResourceTextEquals dict key expectedText =
+                Assert.containsKeyWithValueWith dict key expectedText (fun o -> (o :?> TextBlock).Text)
+
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+
+            let key = "myKey"
+
+            Assert.notContainsKey target key
+
+            let initText = "Hello, World!"
+            let valueView = TextBlock.create [ TextBlock.text initText ]
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, valueView) ]
+
+            VirtualDom.update target initView updatedView
+            assertResourceTextEquals target key initText
+
+            let updatedText = "Goodbye, World!"
+            let updatedValueView = TextBlock.create [ TextBlock.text updatedText ]
+
+            let updatedView2 =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, updatedValueView) ]
+
+            VirtualDom.update target updatedView updatedView2
+
+            assertResourceTextEquals target key updatedText
+
+            let revertedView = ResourceDictionary.create []
+            VirtualDom.update target updatedView revertedView
+
+            Assert.notContainsKey target key
+
+        [<Fact>]
+        let ``with object creates new instance on update`` () =
+            let key = "myKey"
+            let text = "TextBlock Text"
+
+            let view () =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (key, TextBlock(Text = text)) ]
+
+            let initialView = view ()
+            let target = VirtualDom.create initialView
+            let initialTextBlock = Assert.containsKey target key :?> TextBlock
+            Assert.Equal(text, initialTextBlock.Text)
+
+            let updatedView = view ()
+            VirtualDom.update target initialView updatedView
+
+            let updatedTextBlock = Assert.containsKey target key :?> TextBlock
+            Assert.NotEqual(initialTextBlock, updatedTextBlock)
+            Assert.Equal(text, updatedTextBlock.Text)
+
+        [<Fact>]
+        let ``with IView reuses existing instance when patchable`` () =
+            let key = "myKey"
+            let initialText = "Initial Text"
+            let updatedText = "Updated Text"
+
+            let view text =
+                ResourceDictionary.create
+                    [ ResourceDictionary.keyValue (key, TextBlock.create [ TextBlock.text text ]) ]
+
+            let initialView = view initialText
+            let target = VirtualDom.create initialView
+            let initialTextBlock = Assert.containsKey target key :?> TextBlock
+            Assert.Equal(initialText, initialTextBlock.Text)
+
+            let updatedView = view updatedText
+            VirtualDom.update target initialView updatedView
+
+            let updatedTextBlock = Assert.containsKey target key :?> TextBlock
+            Assert.Equal(initialTextBlock, updatedTextBlock)
+            Assert.Equal(updatedText, updatedTextBlock.Text)
diff --git a/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj b/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
index c9a1eeed..e39df28a 100644
--- a/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
+++ b/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
@@ -54,6 +54,7 @@
 
     <Compile Include="DSL\Base\Layoutable.fs" />
     <Compile Include="DSL\Base\Interactive.fs" />
+    <Compile Include="DSL\Base\ResourceDictionary.fs" />
     <Compile Include="DSL\Base\Visual.fs" />
     <Compile Include="DSL\Base\InputElement.fs" />
     <Compile Include="DSL\Base\Control.fs" />
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
new file mode 100644
index 00000000..40f3119b
--- /dev/null
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
@@ -0,0 +1,52 @@
+namespace Avalonia.FuncUI.DSL
+
+[<AutoOpen>]
+module ResourceDictionary =
+    open Avalonia
+    open Avalonia.Controls
+    open Avalonia.FuncUI.Types
+    open Avalonia.FuncUI.Builder
+
+    let create (attrs: IAttr<ResourceDictionary> list) : IView<ResourceDictionary> =
+        ViewBuilder.Create<ResourceDictionary>(attrs)
+
+    /// Type that indicates ResourceDictionary.item has been cleared
+    type private ClearValue = ClearValue
+    
+    type ResourceDictionary with
+        static member keyValue<'t when 't :> ResourceDictionary>(key: obj, value: obj) : IAttr<'t> =
+            let name = $"Item.{key}"
+            let value: obj option = Some value
+            
+            /// `defaultValueFactory` is called during property initialization. Returning `ClearValue` allows the setter to detect when the property is being reset to its default state.
+            let factory: unit -> obj option =
+                (fun () -> Some (box ClearValue))
+            
+            let getter: ('t -> obj option) = (fun control -> Option.ofObj control[key])
+
+            /// When `ClearValue` is passed, the item is removed; otherwise, the value is set.
+            let setter: ('t * obj option -> unit) =
+                (fun (control, value) ->
+                    match value with
+                    | Some (:? ClearValue)  when control.ContainsKey(key) ->
+                        control.Remove(key) |> ignore
+                    | _ ->
+                        control.[key] <- Option.toObj value
+                    )
+            
+
+            AttrBuilder<'t>
+                .CreateProperty<obj option>(name, value, ValueSome getter, ValueSome setter, ValueNone, factory)
+
+        static member keyValue<'t, 'v when 't :> ResourceDictionary>(key: obj, view: IView<'v>) : IAttr<'t> =
+            let name = $"Item.{key}"
+            let singleContent = Some ( view :> IView )
+            let getter: ('t -> obj) = (fun control -> control[key])
+            let setter: ('t * obj -> unit) =
+                (fun (control, value) ->
+                    match value with
+                    | null -> control.Remove(key) |> ignore
+                    | _ -> control.[key] <- value
+                )
+            
+            AttrBuilder<'t>.CreateContentSingle(name, ValueSome getter, ValueSome setter, singleContent)
\ No newline at end of file

From 8eaf8c5949d7c8c873622267e87be34af4bdfa51 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Mon, 3 Nov 2025 22:17:49 +0900
Subject: [PATCH 03/18] Add ResourceDictionary.mergedDictionaries

---
 .../DSL/Base/ResourceDictionaryTests.fs       | 57 +++++++++++++++++++
 .../DSL/Base/ResourceDictionary.fs            | 37 ++++++------
 2 files changed, 78 insertions(+), 16 deletions(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index b1cc319d..f1c65f8a 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -257,3 +257,60 @@ module ResourceDictionaryTests =
             let updatedTextBlock = Assert.containsKey target key :?> TextBlock
             Assert.Equal(initialTextBlock, updatedTextBlock)
             Assert.Equal(updatedText, updatedTextBlock.Text)
+
+    module ``mergedDictionaries`` =
+        [<Fact>]
+        let ``can set merged dictionaries`` () =
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+
+            let dict1 =
+                ResourceDictionary.create [ ResourceDictionary.keyValue ("key1", "value1") ]
+
+            let dict2 =
+                ResourceDictionary.create [ ResourceDictionary.keyValue ("key2", "value2") ]
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ dict1; dict2 ] ]
+
+            VirtualDom.update target initView updatedView
+
+            Assert.containsKeyWithValue target "key1" "value1"
+            Assert.containsKeyWithValue target "key2" "value2"
+
+        [<Fact>]
+        let ``TryGetResource should find resource from later merged dictionary`` () =
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+
+            let sameKey = "sharedKey"
+
+            let dict1 =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (sameKey, "valueFromDict1") ]
+
+            let dict2 =
+                ResourceDictionary.create [ ResourceDictionary.keyValue (sameKey, "valueFromDict2") ]
+
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ dict1; dict2 ] ]
+
+            VirtualDom.update target initView updatedView
+
+            Assert.containsKeyWithValue target sameKey "valueFromDict2"
+
+    [<Fact>]
+    let ``TryGetResource should find itself before merged dictionaries`` () =
+        let initView = ResourceDictionary.create []
+        let target = VirtualDom.create initView
+
+        let key = "myKey"
+
+        let updatedView =
+            ResourceDictionary.create
+                [ ResourceDictionary.keyValue (key, "valueFromMainDict")
+                  ResourceDictionary.mergedDictionaries
+                      [ ResourceDictionary.create [ ResourceDictionary.keyValue (key, "valueFromMergedDict") ] ] ]
+
+        VirtualDom.update target initView updatedView
+
+        Assert.containsKeyWithValue target key "valueFromMainDict"
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
index 40f3119b..898a17ca 100644
--- a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
@@ -12,41 +12,46 @@ module ResourceDictionary =
 
     /// Type that indicates ResourceDictionary.item has been cleared
     type private ClearValue = ClearValue
-    
+
     type ResourceDictionary with
         static member keyValue<'t when 't :> ResourceDictionary>(key: obj, value: obj) : IAttr<'t> =
             let name = $"Item.{key}"
             let value: obj option = Some value
-            
+
             /// `defaultValueFactory` is called during property initialization. Returning `ClearValue` allows the setter to detect when the property is being reset to its default state.
-            let factory: unit -> obj option =
-                (fun () -> Some (box ClearValue))
-            
+            let factory: unit -> obj option = (fun () -> Some(box ClearValue))
+
             let getter: ('t -> obj option) = (fun control -> Option.ofObj control[key])
 
             /// When `ClearValue` is passed, the item is removed; otherwise, the value is set.
             let setter: ('t * obj option -> unit) =
                 (fun (control, value) ->
                     match value with
-                    | Some (:? ClearValue)  when control.ContainsKey(key) ->
-                        control.Remove(key) |> ignore
-                    | _ ->
-                        control.[key] <- Option.toObj value
-                    )
-            
+                    | Some(:? ClearValue) when control.ContainsKey(key) -> control.Remove(key) |> ignore
+                    | _ -> control.[key] <- Option.toObj value)
+
 
             AttrBuilder<'t>
                 .CreateProperty<obj option>(name, value, ValueSome getter, ValueSome setter, ValueNone, factory)
 
         static member keyValue<'t, 'v when 't :> ResourceDictionary>(key: obj, view: IView<'v>) : IAttr<'t> =
             let name = $"Item.{key}"
-            let singleContent = Some ( view :> IView )
+            let singleContent = Some(view :> IView)
             let getter: ('t -> obj) = (fun control -> control[key])
+
             let setter: ('t * obj -> unit) =
                 (fun (control, value) ->
                     match value with
                     | null -> control.Remove(key) |> ignore
-                    | _ -> control.[key] <- value
-                )
-            
-            AttrBuilder<'t>.CreateContentSingle(name, ValueSome getter, ValueSome setter, singleContent)
\ No newline at end of file
+                    | _ -> control.[key] <- value)
+
+            AttrBuilder<'t>
+                .CreateContentSingle(name, ValueSome getter, ValueSome setter, singleContent)
+
+        static member mergedDictionaries<'t when 't :> ResourceDictionary>(dictionaries: IView list) : IAttr<'t> =
+            let name = nameof Unchecked.defaultof<'t>.MergedDictionaries
+
+            let getter = (fun (control: 't) -> control.MergedDictionaries :> obj)
+
+            AttrBuilder<'t>
+                .CreateContentMultiple(name, ValueSome getter, ValueNone, dictionaries)

From d8b9dfd0c4eaaeb7324d9fb4915105bd57252210 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 8 Nov 2025 11:43:45 +0900
Subject: [PATCH 04/18] Add ResourceDictionary.themeDictionariesKeyValue
 binding.

---
 .../DSL/Base/ResourceDictionaryTests.fs       | 82 ++++++++++++++-----
 .../DSL/Base/ResourceDictionary.fs            | 18 ++++
 2 files changed, 79 insertions(+), 21 deletions(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index f1c65f8a..77682467 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -20,24 +20,42 @@ module ResourceDictionaryTests =
             Patcher.patch (target, diff)
 
     module private Assert =
+        open Avalonia.Styling
+        let containsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, theme)
+            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key} for theme: {theme}.")
+            value
+
         let containsKey (dict: ResourceDictionary) (key: obj) =
             let isFound, value = dict.TryGetResource(key, null)
             Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
             value
 
+        let notContainsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, theme)
+            Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key} for theme: {theme}. Found value: {value}")
+
         let notContainsKey (dict: ResourceDictionary) (key: obj) =
             let isFound, value = dict.TryGetResource(key, null)
             Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key}. Found value: {value}")
 
-        let containsKeyWithValueWith (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
-            let isFound, actualValue = dict.TryGetResource(key, null)
+        let containsThemeKeyAndValueEqualWith (dict: ResourceDictionary) (theme: ThemeVariant) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
+            let actualValue = containsThemeKey dict theme key
             let expectedValue = box expectedValue
 
-            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
             Assert.Equal(expectedValue, converter actualValue)
+        
+        let containsThemeKeyAndValueEqual (dict: ResourceDictionary) (theme: ThemeVariant) (key: 'k) (expectedValue: 'v) =
+            containsThemeKeyAndValueEqualWith dict theme key expectedValue (fun o -> o :?> 'v)
 
-        let containsKeyWithValue (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
-            containsKeyWithValueWith dict key expectedValue (fun o -> o :?> 'v)
+        let containsKeyAndValueEqualWith (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
+            let actualValue = containsKey dict key
+            let expectedValue = box expectedValue
+
+            Assert.Equal(expectedValue, converter actualValue)
+
+        let containsKeyAndValueEqual (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
+            containsKeyAndValueEqualWith dict key expectedValue (fun o -> o :?> 'v)
 
     module ``keyValue`` =
 
@@ -57,7 +75,7 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyWithValue target key value
+            Assert.containsKeyAndValueEqual target key value
 
             let revertedView = ResourceDictionary.create []
             VirtualDom.update target updatedView revertedView
@@ -77,7 +95,7 @@ module ResourceDictionaryTests =
                 ResourceDictionary.create [ ResourceDictionary.keyValue (key, value = value) ]
 
             VirtualDom.update target initView updatedView
-            Assert.containsKeyWithValue target key value
+            Assert.containsKeyAndValueEqual target key value
 
             VirtualDom.update target updatedView initView
             Assert.notContainsKey target key
@@ -97,7 +115,7 @@ module ResourceDictionaryTests =
             let initView = createView initialValue
             let target = VirtualDom.create initView
 
-            Assert.containsKeyWithValue target key initialValue
+            Assert.containsKeyAndValueEqual target key initialValue
 
             List.fold
                 (fun lastView acc ->
@@ -105,12 +123,12 @@ module ResourceDictionaryTests =
                     | Choice1Of2(nextValue: obj) ->
                         let updatedView = createView nextValue
                         VirtualDom.update target lastView updatedView
-                        Assert.containsKeyWithValue target key nextValue
+                        Assert.containsKeyAndValueEqual target key nextValue
                         updatedView
                     | Choice2Of2(nextValue, expected, converter) ->
                         let updatedView = createViewWithIView nextValue
                         VirtualDom.update target lastView updatedView
-                        Assert.containsKeyWithValueWith target key expected converter
+                        Assert.containsKeyAndValueEqualWith target key expected converter
                         updatedView)
                 initView
                 [ Choice1Of2 42
@@ -134,7 +152,7 @@ module ResourceDictionaryTests =
 
             let target = VirtualDom.create initView
 
-            Assert.containsKeyWithValue target initialKey value
+            Assert.containsKeyAndValueEqual target initialKey value
 
             let updatedView =
                 ResourceDictionary.create [ ResourceDictionary.keyValue (updatedKey, value) ]
@@ -142,7 +160,7 @@ module ResourceDictionaryTests =
             VirtualDom.update target initView updatedView
 
             Assert.notContainsKey target initialKey
-            Assert.containsKeyWithValue target updatedKey value
+            Assert.containsKeyAndValueEqual target updatedKey value
 
 
         [<Fact>]
@@ -161,8 +179,8 @@ module ResourceDictionaryTests =
 
             let target = VirtualDom.create initView
 
-            Assert.containsKeyWithValue target key1 value1
-            Assert.containsKeyWithValue target key2 value2
+            Assert.containsKeyAndValueEqual target key1 value1
+            Assert.containsKeyAndValueEqual target key2 value2
 
             let updatedView =
                 ResourceDictionary.create
@@ -171,8 +189,8 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyWithValue target key1 updatedValue1
-            Assert.containsKeyWithValue target key2 updatedValue2
+            Assert.containsKeyAndValueEqual target key1 updatedValue1
+            Assert.containsKeyAndValueEqual target key2 updatedValue2
 
             let revertedView = ResourceDictionary.create []
             VirtualDom.update target updatedView revertedView
@@ -183,7 +201,7 @@ module ResourceDictionaryTests =
         [<Fact>]
         let ``can set with IView`` () =
             let assertResourceTextEquals dict key expectedText =
-                Assert.containsKeyWithValueWith dict key expectedText (fun o -> (o :?> TextBlock).Text)
+                Assert.containsKeyAndValueEqualWith dict key expectedText (fun o -> (o :?> TextBlock).Text)
 
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
@@ -275,8 +293,8 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyWithValue target "key1" "value1"
-            Assert.containsKeyWithValue target "key2" "value2"
+            Assert.containsKeyAndValueEqual target "key1" "value1"
+            Assert.containsKeyAndValueEqual target "key2" "value2"
 
         [<Fact>]
         let ``TryGetResource should find resource from later merged dictionary`` () =
@@ -296,7 +314,7 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyWithValue target sameKey "valueFromDict2"
+            Assert.containsKeyAndValueEqual target sameKey "valueFromDict2"
 
     [<Fact>]
     let ``TryGetResource should find itself before merged dictionaries`` () =
@@ -313,4 +331,26 @@ module ResourceDictionaryTests =
 
         VirtualDom.update target initView updatedView
 
-        Assert.containsKeyWithValue target key "valueFromMainDict"
+        Assert.containsKeyAndValueEqual target key "valueFromMainDict"
+
+    module ``themeDictionariesKeyValue`` =
+        open Avalonia.Styling
+        [<Fact>]
+        let ``can set theme dictionaries key value`` () =
+            let key = "themeKey"
+            let darkValue = "darkValue"
+            let lightValue = "lightValue"
+            let view =
+                ResourceDictionary.create
+                    [ ResourceDictionary.themeDictionariesKeyValue
+                        ( ThemeVariant.Dark,
+                          ResourceDictionary.create
+                              [ ResourceDictionary.keyValue (key, darkValue) ] )
+                      ResourceDictionary.themeDictionariesKeyValue
+                        ( ThemeVariant.Light,
+                          ResourceDictionary.create
+                              [ ResourceDictionary.keyValue (key, lightValue) ] ) ]
+            let target = VirtualDom.create view
+ 
+            Assert.containsThemeKeyAndValueEqual target ThemeVariant.Dark key darkValue
+            Assert.containsThemeKeyAndValueEqual target ThemeVariant.Light key lightValue
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
index 898a17ca..9cf20321 100644
--- a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
@@ -6,6 +6,7 @@ module ResourceDictionary =
     open Avalonia.Controls
     open Avalonia.FuncUI.Types
     open Avalonia.FuncUI.Builder
+    open Avalonia.Styling
 
     let create (attrs: IAttr<ResourceDictionary> list) : IView<ResourceDictionary> =
         ViewBuilder.Create<ResourceDictionary>(attrs)
@@ -55,3 +56,20 @@ module ResourceDictionary =
 
             AttrBuilder<'t>
                 .CreateContentMultiple(name, ValueSome getter, ValueNone, dictionaries)
+
+        static member themeDictionariesKeyValue<'t, 'v when 't :> ResourceDictionary and 'v :> IThemeVariantProvider>(key: ThemeVariant, view: IView<'v>) : IAttr<'t> =
+            let name = $"ThemeDictionaries.{key.Key}"
+            let singleContent = Some(view :> IView)
+            let getter: ('t -> obj) = (fun control ->
+                match control.ThemeDictionaries.TryGetValue(key) with
+                | true, value -> value
+                | false,_ -> null)
+
+            let setter: ('t * obj -> unit) =
+                (fun (control, value) ->
+                    match value with
+                    | null -> control.ThemeDictionaries.Remove(key) |> ignore
+                    | _ -> control.ThemeDictionaries.[key] <- value :?> IThemeVariantProvider)
+
+            AttrBuilder<'t>
+                .CreateContentSingle(name, ValueSome getter, ValueSome setter, singleContent)

From 744e3c7c389d64e3782812047478a6ae61888acb Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 8 Nov 2025 21:33:40 +0900
Subject: [PATCH 05/18] Add ResourceProvider.onResourceObservable binding

* Extend subscription system from Control to AvaloniaObject for broader compatibility
* Improve code formatting and documentation with XML comments

Breaking Changes:
- Avalonia.FuncUI.Types.Subscription.Subscribe  now accepts AvaloniaObject instead of Control
---
 .../DSL/Base/ResourceDictionaryTests.fs       | 175 ++++++++++++++++--
 src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj    |   1 +
 src/Avalonia.FuncUI/DSL/AttrBuilder.fs        |   8 +-
 .../DSL/Base/ResourceDictionary.fs            |  14 +-
 .../DSL/Base/ResourceProvider.fs              |  49 +++++
 src/Avalonia.FuncUI/Types.fs                  |   2 +-
 .../VirtualDom/VirtualDom.Delta.fs            |   2 +-
 .../VirtualDom/VirtualDom.Patcher.fs          |  10 +-
 8 files changed, 231 insertions(+), 30 deletions(-)
 create mode 100644 src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 77682467..3e199bb4 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -21,6 +21,7 @@ module ResourceDictionaryTests =
 
     module private Assert =
         open Avalonia.Styling
+
         let containsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
             let isFound, value = dict.TryGetResource(key, theme)
             Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key} for theme: {theme}.")
@@ -33,22 +34,42 @@ module ResourceDictionaryTests =
 
         let notContainsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
             let isFound, value = dict.TryGetResource(key, theme)
-            Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key} for theme: {theme}. Found value: {value}")
+
+            Assert.False(
+                isFound,
+                $"ResourceDictionary unexpectedly contains key: {key} for theme: {theme}. Found value: {value}"
+            )
 
         let notContainsKey (dict: ResourceDictionary) (key: obj) =
             let isFound, value = dict.TryGetResource(key, null)
             Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key}. Found value: {value}")
 
-        let containsThemeKeyAndValueEqualWith (dict: ResourceDictionary) (theme: ThemeVariant) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
+        let containsThemeKeyAndValueEqualWith
+            (dict: ResourceDictionary)
+            (theme: ThemeVariant)
+            (key: 'k)
+            (expectedValue: 'v)
+            (converter: obj -> 'v)
+            =
             let actualValue = containsThemeKey dict theme key
             let expectedValue = box expectedValue
 
             Assert.Equal(expectedValue, converter actualValue)
-        
-        let containsThemeKeyAndValueEqual (dict: ResourceDictionary) (theme: ThemeVariant) (key: 'k) (expectedValue: 'v) =
+
+        let containsThemeKeyAndValueEqual
+            (dict: ResourceDictionary)
+            (theme: ThemeVariant)
+            (key: 'k)
+            (expectedValue: 'v)
+            =
             containsThemeKeyAndValueEqualWith dict theme key expectedValue (fun o -> o :?> 'v)
 
-        let containsKeyAndValueEqualWith (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) (converter: obj -> 'v) =
+        let containsKeyAndValueEqualWith
+            (dict: ResourceDictionary)
+            (key: 'k)
+            (expectedValue: 'v)
+            (converter: obj -> 'v)
+            =
             let actualValue = containsKey dict key
             let expectedValue = box expectedValue
 
@@ -335,22 +356,148 @@ module ResourceDictionaryTests =
 
     module ``themeDictionariesKeyValue`` =
         open Avalonia.Styling
+
         [<Fact>]
         let ``can set theme dictionaries key value`` () =
             let key = "themeKey"
             let darkValue = "darkValue"
             let lightValue = "lightValue"
+
             let view =
                 ResourceDictionary.create
-                    [ ResourceDictionary.themeDictionariesKeyValue
-                        ( ThemeVariant.Dark,
-                          ResourceDictionary.create
-                              [ ResourceDictionary.keyValue (key, darkValue) ] )
-                      ResourceDictionary.themeDictionariesKeyValue
-                        ( ThemeVariant.Light,
-                          ResourceDictionary.create
-                              [ ResourceDictionary.keyValue (key, lightValue) ] ) ]
+                    [ ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Dark,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, darkValue) ]
+                      )
+                      ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Light,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, lightValue) ]
+                      ) ]
+
             let target = VirtualDom.create view
- 
+
             Assert.containsThemeKeyAndValueEqual target ThemeVariant.Dark key darkValue
             Assert.containsThemeKeyAndValueEqual target ThemeVariant.Light key lightValue
+
+
+    module ``onResourceObservable`` =
+        open Avalonia.Styling
+
+        [<Fact>]
+        let ``when Owner is not set, callback is not fired`` () =
+            let key = "observableKey"
+            let value = "observableValue"
+            let mutable isCalled = false
+
+            let callback (_: obj option) = isCalled <- true
+
+            let initView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.onResourceObservable (key, callback)
+                      ResourceDictionary.keyValue (key, value) ]
+
+            let target = VirtualDom.create initView
+            Assert.Null(target.Owner)
+
+            // No Owner set, so callback should not be called
+            Assert.False(isCalled, "Callback was unexpectedly called when Owner is not set.")
+
+
+        [<Fact>]
+        let ``when Owner is set, callback is fired`` () =
+            let target = ResourceDictionary()
+            let host = StyledElement()
+            host.Resources <- target
+            Assert.NotNull(target.Owner)
+
+            let key = "observableKey"
+            let initialValue = "initialValue"
+            let updatedValue = "updatedValue"
+
+            let mutable observedValue: obj option = Some( box "no value changed." )
+            let callback v = observedValue <- v
+
+            let initView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.onResourceObservable (key, callback) ]
+            
+            VirtualDom.update target (ResourceDictionary.create []) initView
+
+            // No initial value set, so observedValue should be None
+            Assert.Equal(None, observedValue)
+
+            let updatedView1 =
+                ResourceDictionary.create
+                    [ ResourceDictionary.keyValue (key, initialValue)
+                      ResourceDictionary.onResourceObservable (key, callback) ]
+
+            VirtualDom.update target initView updatedView1
+
+
+            // Initial notification
+            Assert.Equal(Some(box initialValue), observedValue)
+
+            let updatedView2 =
+                ResourceDictionary.create
+                    [ ResourceDictionary.onResourceObservable (key, callback)
+                      ResourceDictionary.keyValue (key, updatedValue) ]
+
+            VirtualDom.update target updatedView1 updatedView2
+
+            // Notification after update
+            Assert.Equal(Some(box updatedValue), observedValue)
+
+        [<Fact>]
+        let ``defaultThemeVariant tests`` () =
+            let target = ResourceDictionary()
+            let host = StyledElement()
+            host.Resources <- target
+
+            let key = "themeObservableKey"
+            let darkValue = "darkValue"
+            let lightValue = "lightValue"
+
+            let mutable observedValue: obj option = None
+            let callback v = observedValue <- v
+
+            let initView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Dark,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, darkValue) ]
+                      )
+                      ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Light,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, lightValue) ]
+                      )
+                      ResourceDictionary.onResourceObservable (
+                          key,
+                          callback,
+                          defaultThemeVariant = ThemeVariant.Dark
+                      ) ]
+
+            VirtualDom.update target (ResourceDictionary.create []) initView
+
+            // Initial notification with Dark theme
+            Assert.Equal(Some(box darkValue), observedValue)
+
+            let updatedView =
+                ResourceDictionary.create
+                    [ ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Dark,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, darkValue) ]
+                      )
+                      ResourceDictionary.themeDictionariesKeyValue (
+                          ThemeVariant.Light,
+                          ResourceDictionary.create [ ResourceDictionary.keyValue (key, lightValue) ]
+                      )
+                      ResourceDictionary.onResourceObservable (
+                          key,
+                          callback,
+                          defaultThemeVariant = ThemeVariant.Light
+                      ) ]
+
+            VirtualDom.update target initView updatedView
+
+            // Notification after update with Light theme
+            Assert.Equal(Some(box lightValue), observedValue)
diff --git a/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj b/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
index e39df28a..dbfd31f9 100644
--- a/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
+++ b/src/Avalonia.FuncUI/Avalonia.FuncUI.fsproj
@@ -54,6 +54,7 @@
 
     <Compile Include="DSL\Base\Layoutable.fs" />
     <Compile Include="DSL\Base\Interactive.fs" />
+    <Compile Include="DSL\Base\ResourceProvider.fs" />
     <Compile Include="DSL\Base\ResourceDictionary.fs" />
     <Compile Include="DSL\Base\Visual.fs" />
     <Compile Include="DSL\Base\InputElement.fs" />
diff --git a/src/Avalonia.FuncUI/DSL/AttrBuilder.fs b/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
index fff01dd2..01c77a26 100644
--- a/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
+++ b/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
@@ -284,12 +284,16 @@ type AttrBuilder<'view>() =
       ( routedEvent: RoutedEvent<'arg>,
         func: 'arg -> unit,
         ?subPatchOptions: SubPatchOptions ) : IAttr<'view> =
+        let isValiedViewType =
+          typeof<'view>.IsAssignableTo(typeof<Interactive>)
+        if not isValiedViewType then
+          invalidOp $"{nameof<'view>} con't create RoutedEvent subscriptions. It must be derived from Interactive."
 
         // subscribe to avalonia property
         // TODO: extract to helpers module
-        let subscribeFunc (control: Control, _handler: 'h) =
+        let subscribeFunc (control: AvaloniaObject, _handler: 'h) =
             let cts = new CancellationTokenSource()
-            control
+            (control :?> Interactive)
                 .GetObservable(routedEvent)
                 .Subscribe(func, cts.Token)
             cts
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
index 9cf20321..1fbab93d 100644
--- a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
@@ -57,13 +57,17 @@ module ResourceDictionary =
             AttrBuilder<'t>
                 .CreateContentMultiple(name, ValueSome getter, ValueNone, dictionaries)
 
-        static member themeDictionariesKeyValue<'t, 'v when 't :> ResourceDictionary and 'v :> IThemeVariantProvider>(key: ThemeVariant, view: IView<'v>) : IAttr<'t> =
+        static member themeDictionariesKeyValue<'t, 'v when 't :> ResourceDictionary and 'v :> IThemeVariantProvider>
+            (key: ThemeVariant, view: IView<'v>)
+            : IAttr<'t> =
             let name = $"ThemeDictionaries.{key.Key}"
             let singleContent = Some(view :> IView)
-            let getter: ('t -> obj) = (fun control ->
-                match control.ThemeDictionaries.TryGetValue(key) with
-                | true, value -> value
-                | false,_ -> null)
+
+            let getter: ('t -> obj) =
+                (fun control ->
+                    match control.ThemeDictionaries.TryGetValue(key) with
+                    | true, value -> value
+                    | false, _ -> null)
 
             let setter: ('t * obj -> unit) =
                 (fun (control, value) ->
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs
new file mode 100644
index 00000000..36c362bd
--- /dev/null
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs
@@ -0,0 +1,49 @@
+namespace Avalonia.FuncUI.DSL
+
+[<AutoOpen>]
+module ResourceProvider =
+    open Avalonia.Controls
+    open Avalonia.FuncUI.Types
+    open Avalonia.FuncUI.Builder
+    open Avalonia
+
+    type ResourceProvider with
+
+        /// <summary>
+        /// Create subscription from `'view.GetResourceObservable`.
+        /// </summary>
+        /// <remarks>
+        /// - If `'view.Orner` is `null`, `func` is never called.
+        /// - Observation result is wrapped in `option` type: `None` for `null` or `AvaloniaProperty.UnsetValue`, `Some value` otherwise.
+        /// </remarks>
+        static member onResourceObservable<'t when 't :> ResourceProvider>
+            (key: obj, func: obj option -> unit, ?defaultThemeVariant, ?subPatchOptions)
+            : IAttr<'t> =
+            let factory: SubscriptionFactory<obj option> =
+                fun (control, func, token) ->
+                    let callback (v: obj) =
+                        match v with
+                        | null -> None
+                        | v when v = AvaloniaProperty.UnsetValue -> None
+                        | _ -> Some v
+                        |> func
+                    let subscription =
+                        let control = control :?> 't
+
+                        match defaultThemeVariant with
+                        | Some themeVariant -> control.GetResourceObservable(key, defaultThemeVariant=themeVariant)
+                        | None -> control.GetResourceObservable(key)
+                        |> _.Subscribe(callback)
+
+                    token.Register(fun () -> subscription.Dispose()) |> ignore
+
+            let name =
+                let viewType = typeof<'t>.Name
+                let defaultThemeVariantStr =
+                    match defaultThemeVariant with
+                    | Some v -> $".{v}"
+                    | None -> ""
+                $"{viewType}.ResourceObservable.{key}{defaultThemeVariantStr}"
+
+            AttrBuilder<'t>
+                .CreateSubscription<obj option>(name, factory, func, ?subPatchOptions = subPatchOptions)
diff --git a/src/Avalonia.FuncUI/Types.fs b/src/Avalonia.FuncUI/Types.fs
index c464eb0a..a70e42b0 100644
--- a/src/Avalonia.FuncUI/Types.fs
+++ b/src/Avalonia.FuncUI/Types.fs
@@ -62,7 +62,7 @@ module rec Types =
     [<CustomEquality; NoComparison>]
     type Subscription =
         { Name: string
-          Subscribe: Control  * Delegate -> CancellationTokenSource
+          Subscribe: AvaloniaObject * Delegate -> CancellationTokenSource
           Func: Delegate
           FuncType: Type
           Scope: obj }
diff --git a/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Delta.fs b/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Delta.fs
index a095fe1a..dbf3d96e 100644
--- a/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Delta.fs
+++ b/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Delta.fs
@@ -62,7 +62,7 @@ module internal rec Delta =
     [<CustomEquality; NoComparison>]
     type SubscriptionDelta =
         { Name: string
-          Subscribe: Control * Delegate -> CancellationTokenSource
+          Subscribe: AvaloniaObject * Delegate -> CancellationTokenSource
           Func: Delegate option }
 
         override this.Equals (other: obj) : bool =
diff --git a/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Patcher.fs b/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Patcher.fs
index 97de9eb6..f8471f48 100644
--- a/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Patcher.fs
+++ b/src/Avalonia.FuncUI/VirtualDom/VirtualDom.Patcher.fs
@@ -18,7 +18,7 @@ module internal rec Patcher =
          && value.GetType() = viewElement.ViewType
          && not viewElement.KeyDidChange
 
-    let private patchSubscription (view: Control, attr: SubscriptionDelta) : unit =
+    let private patchSubscription (view: AvaloniaObject, attr: SubscriptionDelta) : unit =
         let subscriptions =
             match ViewMetaData.GetViewSubscriptions(view) with
             | null ->
@@ -215,11 +215,7 @@ module internal rec Patcher =
             match attr with
             | AttrDelta.Property property -> patchProperty (view, property)
             | AttrDelta.Content content -> patchContent (view, content)
-            | AttrDelta.Subscription subscription ->
-                match view with
-                | :? Control as control ->
-                    patchSubscription (control, subscription)
-                | _ -> failwith "Only controls can have subscriptions"
+            | AttrDelta.Subscription subscription -> patchSubscription (view, subscription)
             | AttrDelta.SetupFunction _ ->
                 // setup/init functions are only called on control creation
                 ()
@@ -244,7 +240,7 @@ module internal rec Patcher =
         for attr in viewElement.Attrs do
             match attr with
             | AttrDelta.Content content -> Patcher.patchContent (control, content)
-            | AttrDelta.Subscription s -> Patcher.patchSubscription ((control :?> Control), s)
+            | AttrDelta.Subscription s -> Patcher.patchSubscription (control, s)
             | AttrDelta.Property property -> Patcher.patchProperty (control, property)
             | AttrDelta.SetupFunction setupFunction -> setupFunction.Function(control)
 

From 3c6723185e315ea958799bcac93d29828b699d63 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Thu, 13 Nov 2025 18:56:26 +0900
Subject: [PATCH 06/18] Add ResourceInclude bindings with wrapper pattern.

* Support both Uri and string-based factory methods (fromUri, fromString)

Technical Details:
- ResourceInclude doesn't inherit AvaloniaObject, solved with wrapper pattern
- ResourceInclude cannot update internal state, handled by instance recreation
- Added Headless test infrastructure for proper UI thread execution
---
 .../Assets/TestResources1.xaml                |  6 ++
 .../Assets/TestResources2.xaml                |  6 ++
 .../Avalonia.FuncUI.UnitTests.fsproj          |  5 +
 .../DSL/Base/ResourceDictionaryTests.fs       | 93 ++++++++++++++++---
 .../DSL/Base/ResourceDictionary.fs            | 55 +++++++++++
 5 files changed, 151 insertions(+), 14 deletions(-)
 create mode 100644 src/Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml
 create mode 100644 src/Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml

diff --git a/src/Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml b/src/Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml
new file mode 100644
index 00000000..d130ebb4
--- /dev/null
+++ b/src/Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml
@@ -0,0 +1,6 @@
+<ResourceDictionary xmlns='https://github.com/avaloniaui'
+                    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <SolidColorBrush x:Key='BrushA' Color='Red' />
+    <SolidColorBrush x:Key='BrushB' Color='Green' />
+    <SolidColorBrush x:Key='BrushC' Color='Blue' />
+</ResourceDictionary>
\ No newline at end of file
diff --git a/src/Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml b/src/Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml
new file mode 100644
index 00000000..3d020de6
--- /dev/null
+++ b/src/Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml
@@ -0,0 +1,6 @@
+<ResourceDictionary xmlns='https://github.com/avaloniaui'
+                    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <SolidColorBrush x:Key='BrushA' Color='White' />
+    <SolidColorBrush x:Key='BrushB' Color='Black' />
+    <SolidColorBrush x:Key='BrushC' Color='Gray' />
+</ResourceDictionary>
\ No newline at end of file
diff --git a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
index c63e31b0..99a2ce60 100644
--- a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
+++ b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
@@ -11,6 +11,10 @@
     <Optimize>false</Optimize>
   </PropertyGroup>
 
+  <ItemGroup>
+    <AvaloniaResource Include="**\*.xaml" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="LibTests.fs" />
     <Compile Include="VirtualDom\VirtualDom.ModuleTests.fs" />
@@ -23,6 +27,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Avalonia.Headless" Version="$(AvaloniaVersion)" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
     <PackageReference Include="System.Reactive" Version="6.0.1" />
     <PackageReference Include="xunit" Version="2.9.0" />
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 3e199bb4..4dd46a84 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -10,6 +10,25 @@ module ResourceDictionaryTests =
     open Avalonia.FuncUI.Types
     open Avalonia.FuncUI.VirtualDom
 
+    module private Headless =
+        open System
+        open System.Threading
+        open System.Threading.Tasks
+        open Avalonia.Headless
+
+        let useSession () =
+            typeof<Application> |> HeadlessUnitTestSession.StartNew
+
+        let dispatch fn =
+            use session = useSession ()
+            let action = Action fn
+            session.Dispatch(action, CancellationToken.None)
+
+        let dispatchAsync fn =
+            use session = useSession ()
+            let action = Func<Task>(fun () -> fn)
+            session.Dispatch(action, CancellationToken.None)
+
     module private VirtualDom =
         open Avalonia.FuncUI.Builder
 
@@ -298,6 +317,9 @@ module ResourceDictionaryTests =
             Assert.Equal(updatedText, updatedTextBlock.Text)
 
     module ``mergedDictionaries`` =
+        open System
+        open Avalonia.Media
+
         [<Fact>]
         let ``can set merged dictionaries`` () =
             let initView = ResourceDictionary.create []
@@ -337,6 +359,58 @@ module ResourceDictionaryTests =
 
             Assert.containsKeyAndValueEqual target sameKey "valueFromDict2"
 
+        [<Fact>]
+        let ``can add ResourcesInclude to merged dictionaries`` () =
+            Headless.dispatch (fun () ->
+                let initView = ResourceDictionary.create []
+                let target = VirtualDom.create initView
+                let host = StyledElement()
+                host.Resources <- target
+
+                let assertResources kv =
+                    for (key, color) in kv do
+                        let brush = Assert.containsKey target key |> Assert.IsType<SolidColorBrush>
+                        Assert.Equal(color, brush.Color)
+
+                let include1 =
+                    ResourceInclude.fromUri (new Uri("avares://Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml"))
+
+                let updatedView =
+                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1 ] ]
+
+                VirtualDom.update target initView updatedView
+
+                let include1KeyValues =
+                    [ ("BrushA", Colors.Red); ("BrushB", Colors.Green); ("BrushC", Colors.Blue) ]
+
+                // Assert initial resources from include1
+                assertResources include1KeyValues
+
+                let include2 =
+                    ResourceInclude.fromString "avares://Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml"
+
+                // Add another ResourceInclude
+                let updatedView2 =
+                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1; include2 ] ]
+
+                VirtualDom.update target updatedView updatedView2
+
+                let include2KeyValues =
+                    [ ("BrushA", Colors.White); ("BrushB", Colors.Black); ("BrushC", Colors.Gray) ]
+
+                // Now the values should come from include2
+                assertResources include2KeyValues
+
+                // Switch the order of includes
+                let updatedView3 =
+                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include2; include1 ] ]
+
+                VirtualDom.update target updatedView2 updatedView3
+
+                // Now the values should come from include1 again
+                assertResources include1KeyValues)
+
+
     [<Fact>]
     let ``TryGetResource should find itself before merged dictionaries`` () =
         let initView = ResourceDictionary.create []
@@ -414,13 +488,12 @@ module ResourceDictionaryTests =
             let initialValue = "initialValue"
             let updatedValue = "updatedValue"
 
-            let mutable observedValue: obj option = Some( box "no value changed." )
+            let mutable observedValue: obj option = Some(box "no value changed.")
             let callback v = observedValue <- v
 
             let initView =
-                ResourceDictionary.create
-                    [ ResourceDictionary.onResourceObservable (key, callback) ]
-            
+                ResourceDictionary.create [ ResourceDictionary.onResourceObservable (key, callback) ]
+
             VirtualDom.update target (ResourceDictionary.create []) initView
 
             // No initial value set, so observedValue should be None
@@ -470,11 +543,7 @@ module ResourceDictionaryTests =
                           ThemeVariant.Light,
                           ResourceDictionary.create [ ResourceDictionary.keyValue (key, lightValue) ]
                       )
-                      ResourceDictionary.onResourceObservable (
-                          key,
-                          callback,
-                          defaultThemeVariant = ThemeVariant.Dark
-                      ) ]
+                      ResourceDictionary.onResourceObservable (key, callback, defaultThemeVariant = ThemeVariant.Dark) ]
 
             VirtualDom.update target (ResourceDictionary.create []) initView
 
@@ -491,11 +560,7 @@ module ResourceDictionaryTests =
                           ThemeVariant.Light,
                           ResourceDictionary.create [ ResourceDictionary.keyValue (key, lightValue) ]
                       )
-                      ResourceDictionary.onResourceObservable (
-                          key,
-                          callback,
-                          defaultThemeVariant = ThemeVariant.Light
-                      ) ]
+                      ResourceDictionary.onResourceObservable (key, callback, defaultThemeVariant = ThemeVariant.Light) ]
 
             VirtualDom.update target initView updatedView
 
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
index 1fbab93d..a935f68d 100644
--- a/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceDictionary.fs
@@ -77,3 +77,58 @@ module ResourceDictionary =
 
             AttrBuilder<'t>
                 .CreateContentSingle(name, ValueSome getter, ValueSome setter, singleContent)
+
+
+module ResourceInclude =
+    open System
+    open Avalonia.Controls
+    open Avalonia.FuncUI.Types
+    open Avalonia.Styling
+    open Avalonia.Markup.Xaml.Styling
+    open Avalonia.FuncUI.Builder
+
+    type ResourceIncludeWrapper() =
+        inherit ResourceProvider()
+
+        member val private Inner = ResourceInclude(baseUri = null) with get, set
+        member this.Source
+            with get() = this.Inner.Source
+            and set(value) =
+                match this.Inner.Source with
+                | null -> this.Inner.Source <- value
+                | _ when this.Inner.Source = value -> ()
+                | _ ->
+                    // ResourceInclude never updates inner when Source is changed,
+                    // so we need to create a new instance to reflect the change.
+                    this.Inner <- ResourceInclude(baseUri = null, Source = value)
+
+        override this.HasResources: bool =
+            (this.Inner :> IResourceProvider).HasResources
+        override this.OnAddOwner(owner: IResourceHost): unit =
+            (this.Inner :> IResourceProvider).AddOwner(owner)
+        override this.OnRemoveOwner(owner: IResourceHost): unit =
+            (this.Inner :> IResourceProvider).RemoveOwner(owner)
+
+        override this.TryGetResource(key: obj, theme: ThemeVariant, value: byref<obj>): bool =
+            (this.Inner :> IResourceProvider).TryGetResource(key, theme, &value)
+        
+        static member source<'t when 't :> ResourceIncludeWrapper>(source: Uri) : IAttr<'t> =
+            let name = nameof Unchecked.defaultof<'t>.Source
+
+            let getter: ('t -> Uri) = (fun control -> control.Source)
+
+            let setter: ('t * Uri -> unit) =
+                (fun (control, value) -> control.Source <- value)
+
+            AttrBuilder<'t>
+                .CreateProperty<Uri>(name, source, ValueSome getter, ValueSome setter, ValueNone)
+        
+    let create (attrs: IAttr<ResourceIncludeWrapper> list) : IView<ResourceIncludeWrapper> =
+        ViewBuilder.Create<ResourceIncludeWrapper>(attrs)
+    let fromUri ( source: Uri) : IView<ResourceIncludeWrapper> =
+        create [
+            ResourceIncludeWrapper.source source
+        ]
+
+    let fromString ( source: string) : IView<ResourceIncludeWrapper> =
+        Uri source |> fromUri
\ No newline at end of file

From 6baee78b58adbce8038c6a0e77aade940ac6382e Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Thu, 13 Nov 2025 19:03:00 +0900
Subject: [PATCH 07/18] fix testCase function.

---
 .../DSL/Base/ResourceDictionaryTests.fs                         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 4dd46a84..1072c280 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -123,7 +123,7 @@ module ResourceDictionaryTests =
             Assert.notContainsKey target key
 
         [<Fact>]
-        let ``can set null value`` =
+        let ``can set null value`` () =
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
 

From 26b571860242e3e62f0bb4605c705ad42535f1fd Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:58:38 +0900
Subject: [PATCH 08/18] feat: Add StyledElement.resources overload with
 enhanced test infrastructure

- Add StyledElement.resources IView overload for DSL-style resource management
- Create TestHelpers.fs with reusable Headless, VirtualDom, and Assert modules
- Reorganize tests by functionality with improved module structure
---
 .../Avalonia.FuncUI.UnitTests.fsproj          |   1 +
 .../DSL/Base/ResourceDictionaryTests.fs       | 170 +++--------
 .../DSL/Base/StyledElementTests.fs            | 263 +++++++++++-------
 .../DSL/TestHelpers.fs                        |  95 +++++++
 src/Avalonia.FuncUI/DSL/Base/StyledElement.fs |  12 +-
 5 files changed, 318 insertions(+), 223 deletions(-)
 create mode 100644 src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs

diff --git a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
index 99a2ce60..bc913438 100644
--- a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
+++ b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
@@ -20,6 +20,7 @@
     <Compile Include="VirtualDom\VirtualDom.ModuleTests.fs" />
     <Compile Include="VirtualDom\VirtualDom.DifferTests.fs" />
     <Compile Include="VirtualDom\VirtualDom.PatcherTests.fs" />
+    <Compile Include="DSL\TestHelpers.fs" />
     <Compile Include="DSL\Base\ResourceDictionaryTests.fs" />
     <Compile Include="DSL\Base\StyledElementTests.fs" />
     <Compile Include="State.fs" />
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 1072c280..74bfcddc 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -5,101 +5,10 @@ open Avalonia.Controls
 open global.Xunit
 
 module ResourceDictionaryTests =
-    open Avalonia.FuncUI.VirtualDom
     open Avalonia.FuncUI.DSL
-    open Avalonia.FuncUI.Types
-    open Avalonia.FuncUI.VirtualDom
-
-    module private Headless =
-        open System
-        open System.Threading
-        open System.Threading.Tasks
-        open Avalonia.Headless
-
-        let useSession () =
-            typeof<Application> |> HeadlessUnitTestSession.StartNew
-
-        let dispatch fn =
-            use session = useSession ()
-            let action = Action fn
-            session.Dispatch(action, CancellationToken.None)
-
-        let dispatchAsync fn =
-            use session = useSession ()
-            let action = Func<Task>(fun () -> fn)
-            session.Dispatch(action, CancellationToken.None)
-
-    module private VirtualDom =
-        open Avalonia.FuncUI.Builder
-
-        let create<'t when 't :> AvaloniaObject> (view: IView<'t>) : 't = VirtualDom.createObject view :?> 't
-
-        let update<'t when 't :> AvaloniaObject> (target: 't) (last: IView<'t>) (next: IView<'t>) : unit =
-            let diff = Differ.diff (last, next)
-            Patcher.patch (target, diff)
-
-    module private Assert =
-        open Avalonia.Styling
-
-        let containsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
-            let isFound, value = dict.TryGetResource(key, theme)
-            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key} for theme: {theme}.")
-            value
-
-        let containsKey (dict: ResourceDictionary) (key: obj) =
-            let isFound, value = dict.TryGetResource(key, null)
-            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
-            value
-
-        let notContainsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
-            let isFound, value = dict.TryGetResource(key, theme)
-
-            Assert.False(
-                isFound,
-                $"ResourceDictionary unexpectedly contains key: {key} for theme: {theme}. Found value: {value}"
-            )
-
-        let notContainsKey (dict: ResourceDictionary) (key: obj) =
-            let isFound, value = dict.TryGetResource(key, null)
-            Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key}. Found value: {value}")
-
-        let containsThemeKeyAndValueEqualWith
-            (dict: ResourceDictionary)
-            (theme: ThemeVariant)
-            (key: 'k)
-            (expectedValue: 'v)
-            (converter: obj -> 'v)
-            =
-            let actualValue = containsThemeKey dict theme key
-            let expectedValue = box expectedValue
-
-            Assert.Equal(expectedValue, converter actualValue)
-
-        let containsThemeKeyAndValueEqual
-            (dict: ResourceDictionary)
-            (theme: ThemeVariant)
-            (key: 'k)
-            (expectedValue: 'v)
-            =
-            containsThemeKeyAndValueEqualWith dict theme key expectedValue (fun o -> o :?> 'v)
-
-        let containsKeyAndValueEqualWith
-            (dict: ResourceDictionary)
-            (key: 'k)
-            (expectedValue: 'v)
-            (converter: obj -> 'v)
-            =
-            let actualValue = containsKey dict key
-            let expectedValue = box expectedValue
-
-            Assert.Equal(expectedValue, converter actualValue)
-
-        let containsKeyAndValueEqual (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
-            containsKeyAndValueEqualWith dict key expectedValue (fun o -> o :?> 'v)
 
     module ``keyValue`` =
 
-
         [<Fact>]
         let ``can set`` () =
             let initView = ResourceDictionary.create []
@@ -108,19 +17,19 @@ module ResourceDictionaryTests =
             let key = "myKey"
             let value = "myValue"
 
-            Assert.notContainsKey target key
+            Assert.ResourceDictionary.notContainsKey target key
 
             let updatedView =
                 ResourceDictionary.create [ ResourceDictionary.keyValue (key, value) ]
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyAndValueEqual target key value
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key value
 
             let revertedView = ResourceDictionary.create []
             VirtualDom.update target updatedView revertedView
 
-            Assert.notContainsKey target key
+            Assert.ResourceDictionary.notContainsKey target key
 
         [<Fact>]
         let ``can set null value`` () =
@@ -129,16 +38,16 @@ module ResourceDictionaryTests =
 
             let key = "myKey"
             let value = null
-            Assert.notContainsKey target key
+            Assert.ResourceDictionary.notContainsKey target key
 
             let updatedView =
                 ResourceDictionary.create [ ResourceDictionary.keyValue (key, value = value) ]
 
             VirtualDom.update target initView updatedView
-            Assert.containsKeyAndValueEqual target key value
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key value
 
             VirtualDom.update target updatedView initView
-            Assert.notContainsKey target key
+            Assert.ResourceDictionary.notContainsKey target key
 
 
         [<Fact>]
@@ -155,7 +64,7 @@ module ResourceDictionaryTests =
             let initView = createView initialValue
             let target = VirtualDom.create initView
 
-            Assert.containsKeyAndValueEqual target key initialValue
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key initialValue
 
             List.fold
                 (fun lastView acc ->
@@ -163,12 +72,12 @@ module ResourceDictionaryTests =
                     | Choice1Of2(nextValue: obj) ->
                         let updatedView = createView nextValue
                         VirtualDom.update target lastView updatedView
-                        Assert.containsKeyAndValueEqual target key nextValue
+                        Assert.ResourceDictionary.containsKeyAndValueEqual target key nextValue
                         updatedView
                     | Choice2Of2(nextValue, expected, converter) ->
                         let updatedView = createViewWithIView nextValue
                         VirtualDom.update target lastView updatedView
-                        Assert.containsKeyAndValueEqualWith target key expected converter
+                        Assert.ResourceDictionary.containsKeyAndValueEqualWith target key expected converter
                         updatedView)
                 initView
                 [ Choice1Of2 42
@@ -192,15 +101,15 @@ module ResourceDictionaryTests =
 
             let target = VirtualDom.create initView
 
-            Assert.containsKeyAndValueEqual target initialKey value
+            Assert.ResourceDictionary.containsKeyAndValueEqual target initialKey value
 
             let updatedView =
                 ResourceDictionary.create [ ResourceDictionary.keyValue (updatedKey, value) ]
 
             VirtualDom.update target initView updatedView
 
-            Assert.notContainsKey target initialKey
-            Assert.containsKeyAndValueEqual target updatedKey value
+            Assert.ResourceDictionary.notContainsKey target initialKey
+            Assert.ResourceDictionary.containsKeyAndValueEqual target updatedKey value
 
 
         [<Fact>]
@@ -219,8 +128,8 @@ module ResourceDictionaryTests =
 
             let target = VirtualDom.create initView
 
-            Assert.containsKeyAndValueEqual target key1 value1
-            Assert.containsKeyAndValueEqual target key2 value2
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key1 value1
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key2 value2
 
             let updatedView =
                 ResourceDictionary.create
@@ -229,27 +138,27 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyAndValueEqual target key1 updatedValue1
-            Assert.containsKeyAndValueEqual target key2 updatedValue2
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key1 updatedValue1
+            Assert.ResourceDictionary.containsKeyAndValueEqual target key2 updatedValue2
 
             let revertedView = ResourceDictionary.create []
             VirtualDom.update target updatedView revertedView
 
-            Assert.notContainsKey target key1
-            Assert.notContainsKey target key2
+            Assert.ResourceDictionary.notContainsKey target key1
+            Assert.ResourceDictionary.notContainsKey target key2
 
         [<Fact>]
         let ``can set with IView`` () =
             let assertResourceTextEquals dict key expectedText =
-                Assert.containsKeyAndValueEqualWith dict key expectedText (fun o -> (o :?> TextBlock).Text)
+                Assert.ResourceDictionary.containsKeyAndValueEqualWith dict key expectedText (fun o ->
+                    (o :?> TextBlock).Text)
 
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
 
             let key = "myKey"
 
-            Assert.notContainsKey target key
-
+            Assert.ResourceDictionary.notContainsKey target key
             let initText = "Hello, World!"
             let valueView = TextBlock.create [ TextBlock.text initText ]
 
@@ -272,7 +181,7 @@ module ResourceDictionaryTests =
             let revertedView = ResourceDictionary.create []
             VirtualDom.update target updatedView revertedView
 
-            Assert.notContainsKey target key
+            Assert.ResourceDictionary.notContainsKey target key
 
         [<Fact>]
         let ``with object creates new instance on update`` () =
@@ -284,13 +193,18 @@ module ResourceDictionaryTests =
 
             let initialView = view ()
             let target = VirtualDom.create initialView
-            let initialTextBlock = Assert.containsKey target key :?> TextBlock
+
+            let initialTextBlock =
+                Assert.ResourceDictionary.containsKey target key :?> TextBlock
+
             Assert.Equal(text, initialTextBlock.Text)
 
             let updatedView = view ()
             VirtualDom.update target initialView updatedView
 
-            let updatedTextBlock = Assert.containsKey target key :?> TextBlock
+            let updatedTextBlock =
+                Assert.ResourceDictionary.containsKey target key :?> TextBlock
+
             Assert.NotEqual(initialTextBlock, updatedTextBlock)
             Assert.Equal(text, updatedTextBlock.Text)
 
@@ -306,13 +220,18 @@ module ResourceDictionaryTests =
 
             let initialView = view initialText
             let target = VirtualDom.create initialView
-            let initialTextBlock = Assert.containsKey target key :?> TextBlock
+
+            let initialTextBlock =
+                Assert.ResourceDictionary.containsKey target key :?> TextBlock
+
             Assert.Equal(initialText, initialTextBlock.Text)
 
             let updatedView = view updatedText
             VirtualDom.update target initialView updatedView
 
-            let updatedTextBlock = Assert.containsKey target key :?> TextBlock
+            let updatedTextBlock =
+                Assert.ResourceDictionary.containsKey target key :?> TextBlock
+
             Assert.Equal(initialTextBlock, updatedTextBlock)
             Assert.Equal(updatedText, updatedTextBlock.Text)
 
@@ -336,8 +255,8 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyAndValueEqual target "key1" "value1"
-            Assert.containsKeyAndValueEqual target "key2" "value2"
+            Assert.ResourceDictionary.containsKeyAndValueEqual target "key1" "value1"
+            Assert.ResourceDictionary.containsKeyAndValueEqual target "key2" "value2"
 
         [<Fact>]
         let ``TryGetResource should find resource from later merged dictionary`` () =
@@ -357,7 +276,7 @@ module ResourceDictionaryTests =
 
             VirtualDom.update target initView updatedView
 
-            Assert.containsKeyAndValueEqual target sameKey "valueFromDict2"
+            Assert.ResourceDictionary.containsKeyAndValueEqual target sameKey "valueFromDict2"
 
         [<Fact>]
         let ``can add ResourcesInclude to merged dictionaries`` () =
@@ -369,7 +288,10 @@ module ResourceDictionaryTests =
 
                 let assertResources kv =
                     for (key, color) in kv do
-                        let brush = Assert.containsKey target key |> Assert.IsType<SolidColorBrush>
+                        let brush =
+                            Assert.ResourceDictionary.containsKey target key
+                            |> Assert.IsType<SolidColorBrush>
+
                         Assert.Equal(color, brush.Color)
 
                 let include1 =
@@ -426,7 +348,7 @@ module ResourceDictionaryTests =
 
         VirtualDom.update target initView updatedView
 
-        Assert.containsKeyAndValueEqual target key "valueFromMainDict"
+        Assert.ResourceDictionary.containsKeyAndValueEqual target key "valueFromMainDict"
 
     module ``themeDictionariesKeyValue`` =
         open Avalonia.Styling
@@ -450,8 +372,8 @@ module ResourceDictionaryTests =
 
             let target = VirtualDom.create view
 
-            Assert.containsThemeKeyAndValueEqual target ThemeVariant.Dark key darkValue
-            Assert.containsThemeKeyAndValueEqual target ThemeVariant.Light key lightValue
+            Assert.ResourceDictionary.containsThemeKeyAndValueEqual target ThemeVariant.Dark key darkValue
+            Assert.ResourceDictionary.containsThemeKeyAndValueEqual target ThemeVariant.Light key lightValue
 
 
     module ``onResourceObservable`` =
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
index 44782d1c..765a64e0 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
@@ -5,145 +5,212 @@ open Avalonia.Controls
 open global.Xunit
 
 module StyledElementTests =
-    open Avalonia.FuncUI.VirtualDom
+    open Avalonia.Styling
     open Avalonia.FuncUI.DSL
     open Avalonia.FuncUI.Types
-    open Avalonia.Styling
+
+    module StyledElement =
+        // create function here for tests
+        let create (attrs: IAttr<StyledElement> list): IView<StyledElement> =
+            ViewBuilder.Create<StyledElement>(attrs)
 
     let twoAttrs<'x, 't> (attr: 'x -> IAttr<'t>) a b =
         [ attr a :> IAttr ], [ attr b :> IAttr ]
 
-    [<Fact>]
-    let ``classes equality with string list`` () =
-        let valueList() = [ "class1"; "class2" ]
+    module ``classes`` =
+        open Avalonia.FuncUI.VirtualDom
+
+        [<Fact>]
+        let ``equality with string list`` () =
+            let valueList () = [ "class1"; "class2" ]
+
+            let classes1 = valueList ()
+            let classes2 = valueList ()
+
+            let stringList =
+                (classes1, classes2) ||> twoAttrs StyledElement.classes |> Differ.diffAttributes
+
+            Assert.Empty stringList
+
+        [<Fact>]
+        let ``equality with same classes instance`` () =
+            let classes = Classes()
+            classes.Add "class1"
+            classes.Add "class2"
+
+            let sameClassesInstance =
+                (classes, classes) ||> twoAttrs StyledElement.classes |> Differ.diffAttributes
+
+            Assert.Empty sameClassesInstance
+
+        [<Fact>]
+        let ``equality with different classes instance`` () =
+            let classes1 = Classes()
+            classes1.Add "class1"
+            classes1.Add "class2"
+
+            let classes2 = Classes()
+            classes2.Add "class1"
+            classes2.Add "class2"
+
+            let differentClassesInstance =
+                (classes1, classes2) ||> twoAttrs StyledElement.classes |> Differ.diffAttributes
+
+            Assert.Empty differentClassesInstance
+
+
+    module ``styles`` =
+        open Avalonia.FuncUI.VirtualDom
+
+        let initStyle () =
+            let s = Style(fun x -> x.Is<Control>())
+            s.Setters.Add(Setter(Control.TagProperty, "foo"))
+            s :> IStyle
+
+        [<Fact>]
+        let ``equality with style list has same style instance`` () =
+            let style = initStyle ()
+
+            let styleList () = [ style ]
+
+            let styles1 = styleList ()
+            let styles2 = styleList ()
+
+            let styleList =
+                (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
 
-        let classes1 = valueList()
-        let classes2 = valueList()
+            Assert.Empty styleList
 
-        let stringList =
-            (classes1, classes2)
-            ||> twoAttrs StyledElement.classes
-            |> Differ.diffAttributes
 
-        Assert.Empty stringList
+        [<Fact>]
+        let ``equality with style list has different style instance`` () =
 
-    [<Fact>]
-    let ``classes equality with same classes instance`` () =
-        let classes = Classes()
-        classes.Add "class1"
-        classes.Add "class2"
+            let style1 = initStyle ()
+            let style2 = initStyle ()
 
-        let sameClassesInstance =
-            (classes, classes) ||> twoAttrs StyledElement.classes |> Differ.diffAttributes
+            let styleList =
+                ([ style1 ], [ style2 ])
+                ||> twoAttrs StyledElement.styles
+                |> Differ.diffAttributes
 
-        Assert.Empty sameClassesInstance
+            match Assert.Single styleList with
+            | Delta.AttrDelta.Property { Accessor = InstanceProperty { Name = propName }
+                                         Value = Some(:? list<IStyle> as [ value ]) } ->
+                Assert.Equal("Styles", propName)
+                Assert.NotEqual(style1, value)
+                Assert.Equal(style2, value)
 
-    [<Fact>]
-    let ``classes equality with different classes instance`` () =
-        let classes1 = Classes()
-        classes1.Add "class1"
-        classes1.Add "class2"
+            | _ -> Assert.Fail $"Not expected delta\n{styleList}"
 
-        let classes2 = Classes()
-        classes2.Add "class1"
-        classes2.Add "class2"
+        [<Fact>]
+        let ``equality with Styles property has same instance`` () =
+            let style = initStyle ()
 
-        let differentClassesInstance =
-            (classes1, classes2) ||> twoAttrs StyledElement.classes |> Differ.diffAttributes
+            let styles = Styles()
+            styles.Add style
 
-        Assert.Empty differentClassesInstance
+            let styles1 = styles
+            let styles2 = styles
 
-    let initStyle () =
-        let s = Style(fun x -> x.Is<Control>())
-        s.Setters.Add(Setter(Control.TagProperty, "foo"))
-        s :> IStyle
+            let styleList =
+                (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
 
-    [<Fact>]
-    let ``styles equality with style list has same style instance`` () =
-        let style = initStyle ()
+            Assert.Empty styleList
 
-        let styleList () = [ style ]
+        [<Fact>]
+        let ``equality with Styles property has different Styles instance has same style instance`` () =
+            let style = initStyle ()
 
-        let styles1 = styleList ()
-        let styles2 = styleList ()
+            let styles1 = Styles()
+            styles1.Add style
+            styles1.Resources.Add("key", "value")
 
-        let styleList =
-            (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
+            let styles2 = Styles()
+            styles2.Add style
+            styles2.Resources.Add("key", "value")
 
-        Assert.Empty styleList
+            let styleList =
+                (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
 
+            Assert.Empty styleList
 
-    [<Fact>]
-    let ``styles equality with style list has different style instance`` () =
+        [<Fact>]
+        let ``equality with Styles property has different Styles instance has different style instance`` () =
+            let style1 = initStyle ()
+            let style2 = initStyle ()
 
-        let style1 = initStyle ()
-        let style2 = initStyle ()
+            let styles1 = Styles()
+            styles1.Add style1
+            styles1.Resources.Add("key", "value")
 
-        let styleList =
-            ([ style1 ], [ style2 ]) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
+            let styles2 = Styles()
+            styles2.Add style2
+            styles2.Resources.Add("key", "value")
 
-        match Assert.Single styleList with
-        | Delta.AttrDelta.Property { Accessor = InstanceProperty { Name = propName }
-                                     Value = Some(:? list<IStyle> as [ value ]) } ->
-            Assert.Equal("Styles", propName)
-            Assert.NotEqual(style1, value)
-            Assert.Equal(style2, value)
+            let styleList =
+                (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
 
-        | _ -> Assert.Fail $"Not expected delta\n{styleList}"
+            match Assert.Single styleList with
+            | Delta.AttrDelta.Property { Accessor = InstanceProperty { Name = propName }
+                                         Value = Some(:? Styles as value) } ->
+                Assert.Equal("Styles", propName)
+                Assert.NotEqual<Styles>(styles1, value)
+                Assert.Equal<Styles>(styles2, value)
 
-    [<Fact>]
-    let ``styles equality with Styles property has same instance`` () =
-        let style = initStyle ()
+            | _ -> Assert.Fail $"Not expected delta\n{styleList}"
 
-        let styles = Styles()
-        styles.Add style
+    module ``resources`` =
+        let assertResource (target: StyledElement) key : 't =
+            let isFound, resValue = target.TryGetResource(key)
+            Assert.True isFound
+            Assert.IsType<'t>(resValue)
 
-        let styles1 = styles
-        let styles2 = styles
+        [<Fact>]
+        let ``con set empty dictionary`` () =
+            let initView =
+                StyledElement.create [ StyledElement.resources (ResourceDictionary.create []) ]
 
-        let styleList =
-            (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
+            let target = VirtualDom.create initView
 
-        Assert.Empty styleList
+            Assert.False target.Resources.HasResources
 
-    [<Fact>]
-    let ``styles equality with Styles property has different Styles instance has same style instance`` () =
-        let style = initStyle ()
+        [<Fact>]
+        let ``can set dictionary with values`` () =
+            let initView =
+                StyledElement.create
+                    [ StyledElement.resources (
+                          ResourceDictionary.create
+                              [ ResourceDictionary.keyValue ("key1", "value1")
+                                ResourceDictionary.keyValue ("key2", 42) ]
+                      ) ]
 
-        let styles1 = Styles()
-        styles1.Add style
-        styles1.Resources.Add("key", "value")
+            let target = VirtualDom.create initView
 
-        let styles2 = Styles()
-        styles2.Add style
-        styles2.Resources.Add("key", "value")
+            let assertResource key = assertResource target key
 
-        let styleList =
-            (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
+            Assert.True target.Resources.HasResources
 
-        Assert.Empty styleList
+            Assert.Equal("value1", assertResource "key1")
+            Assert.Equal(42, assertResource "key2")
 
-    [<Fact>]
-    let ``styles equality with Styles property has different Styles instance has different style instance`` () =
-        let style1 = initStyle ()
-        let style2 = initStyle ()
+        [<Fact>]
+        let ``can update dictionary`` () =
+            let initView =
+                StyledElement.create
+                    [ StyledElement.resources (
+                          ResourceDictionary.create [ ResourceDictionary.keyValue ("key1", "value1") ]
+                      ) ]
 
-        let styles1 = Styles()
-        styles1.Add style1
-        styles1.Resources.Add("key", "value")
+            let updatedView =
+                StyledElement.create
+                    [ StyledElement.resources (ResourceDictionary.create [ ResourceDictionary.keyValue ("key2", 42) ]) ]
 
-        let styles2 = Styles()
-        styles2.Add style2
-        styles2.Resources.Add("key", "value")
+            let target = VirtualDom.create initView
+            let assertResource key = assertResource target key
 
-        let styleList =
-            (styles1, styles2) ||> twoAttrs StyledElement.styles |> Differ.diffAttributes
+            Assert.True target.Resources.HasResources
+            Assert.Equal("value1", assertResource "key1")
 
-        match Assert.Single styleList with
-        | Delta.AttrDelta.Property { Accessor = InstanceProperty { Name = propName }
-                                     Value = Some(:? Styles as value) } ->
-            Assert.Equal("Styles", propName)
-            Assert.NotEqual<Styles>(styles1, value)
-            Assert.Equal<Styles>(styles2, value)
+            VirtualDom.update target initView updatedView
 
-        | _ -> Assert.Fail $"Not expected delta\n{styleList}"
+            Assert.Equal(42, assertResource "key2")
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs b/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs
new file mode 100644
index 00000000..4227115a
--- /dev/null
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs
@@ -0,0 +1,95 @@
+namespace Avalonia.FuncUI.UnitTests.DSL
+
+open Avalonia
+
+module Headless =
+    open System
+    open System.Threading
+    open System.Threading.Tasks
+    open Avalonia.Headless
+
+    let useSession () =
+        typeof<Application> |> HeadlessUnitTestSession.StartNew
+
+    let dispatch fn =
+        use session = useSession ()
+        let action = Action fn
+        session.Dispatch(action, CancellationToken.None)
+
+    let dispatchAsync fn =
+        use session = useSession ()
+        let action = Func<Task>(fun () -> fn)
+        session.Dispatch(action, CancellationToken.None)
+
+module VirtualDom =
+    open Avalonia.FuncUI.VirtualDom
+    open Avalonia.FuncUI.Types
+
+    let create<'t when 't :> AvaloniaObject> (view: IView<'t>) : 't = VirtualDom.createObject view :?> 't
+
+    let update<'t when 't :> AvaloniaObject> (target: 't) (last: IView<'t>) (next: IView<'t>) : unit =
+        let diff = Differ.diff (last, next)
+        Patcher.patch (target, diff)
+
+module Assert =
+    open global.Xunit
+    open Avalonia.Styling
+    open Avalonia.Controls
+
+    module ResourceDictionary =
+
+        let containsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, theme)
+            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key} for theme: {theme}.")
+            value
+
+        let containsKey (dict: ResourceDictionary) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, null)
+            Assert.True(isFound, $"ResourceDictionary does not contain expected key: {key}.")
+            value
+
+        let notContainsThemeKey (dict: ResourceDictionary) (theme: ThemeVariant) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, theme)
+
+            Assert.False(
+                isFound,
+                $"ResourceDictionary unexpectedly contains key: {key} for theme: {theme}. Found value: {value}"
+            )
+
+        let notContainsKey (dict: ResourceDictionary) (key: obj) =
+            let isFound, value = dict.TryGetResource(key, null)
+            Assert.False(isFound, $"ResourceDictionary unexpectedly contains key: {key}. Found value: {value}")
+
+        let containsThemeKeyAndValueEqualWith
+            (dict: ResourceDictionary)
+            (theme: ThemeVariant)
+            (key: 'k)
+            (expectedValue: 'v)
+            (converter: obj -> 'v)
+            =
+            let actualValue = containsThemeKey dict theme key
+            let expectedValue = box expectedValue
+
+            Assert.Equal(expectedValue, converter actualValue)
+
+        let containsThemeKeyAndValueEqual
+            (dict: ResourceDictionary)
+            (theme: ThemeVariant)
+            (key: 'k)
+            (expectedValue: 'v)
+            =
+            containsThemeKeyAndValueEqualWith dict theme key expectedValue (fun o -> o :?> 'v)
+
+        let containsKeyAndValueEqualWith
+            (dict: ResourceDictionary)
+            (key: 'k)
+            (expectedValue: 'v)
+            (converter: obj -> 'v)
+            =
+            let actualValue = containsKey dict key
+            let expectedValue = box expectedValue
+
+            Assert.Equal(expectedValue, converter actualValue)
+
+        let containsKeyAndValueEqual (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
+            containsKeyAndValueEqualWith dict key expectedValue (fun o -> o :?> 'v)
\ No newline at end of file
diff --git a/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs b/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
index 8198306b..8f7a9acb 100644
--- a/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
@@ -258,7 +258,17 @@ module StyledElement =
             let factory = fun () -> ResourceDictionary() :> IResourceDictionary
             
             AttrBuilder<'t>.CreateProperty<IResourceDictionary>("Resources", value, ValueSome getter, ValueSome setter, ValueNone, factory)
-            
+        
+        static member resources<'t when 't :> StyledElement>(view: IView) : IAttr<'t> =
+            let name = "ResourcesProperty"
+            let singleContent = Some view
+            let getter: ('t -> obj) = fun control -> control.Resources :> obj
+            let setter: ('t * obj -> unit) =
+                fun (control, value) ->
+                    control.Resources <- value :?> IResourceDictionary
+
+            AttrBuilder<'t>.CreateContentSingle(name, ValueSome getter, ValueSome setter,singleContent)
+
         // Attached properties related to text input
         
         static member contentType<'t when 't :> StyledElement>(value) : IAttr<'t> =

From a80c9791971fd8d4c4316fad4264fbe6b06420cd Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Fri, 14 Nov 2025 19:19:35 +0900
Subject: [PATCH 09/18] Add StyledElement.onResourceObservable binding

---
 .../DSL/Base/StyledElementTests.fs            | 38 ++++++++++++++++++-
 src/Avalonia.FuncUI/DSL/Base/StyledElement.fs | 25 ++++++++++++
 2 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
index 765a64e0..10d03b57 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
@@ -11,7 +11,7 @@ module StyledElementTests =
 
     module StyledElement =
         // create function here for tests
-        let create (attrs: IAttr<StyledElement> list): IView<StyledElement> =
+        let create (attrs: IAttr<StyledElement> list) : IView<StyledElement> =
             ViewBuilder.Create<StyledElement>(attrs)
 
     let twoAttrs<'x, 't> (attr: 'x -> IAttr<'t>) a b =
@@ -214,3 +214,39 @@ module StyledElementTests =
             VirtualDom.update target initView updatedView
 
             Assert.Equal(42, assertResource "key2")
+
+    module ``onResourceObservable`` =
+
+        [<Fact>]
+        let ``observes resource changes with multiple types`` () =
+            let mutable observedValue: obj option = Some(box "no value changed.")
+            let callback v = observedValue <- v
+
+            let key = "testKey"
+
+            let mutable currentView =
+                StyledElement.create [ StyledElement.onResourceObservable (key, callback) ]
+
+            let target = VirtualDom.create currentView
+
+            Assert.Equal(None, observedValue)
+
+            let updateValueAndAssert value =
+                let value = box value
+
+                let updatedView =
+                    StyledElement.create
+                        [ StyledElement.onResourceObservable (key, callback)
+                          StyledElement.resources (
+                              ResourceDictionary.create [ ResourceDictionary.keyValue (key, value) ]
+                          ) ]
+
+                VirtualDom.update target currentView updatedView
+
+                Assert.Equal(Some value, observedValue)
+
+                currentView <- updatedView
+
+            updateValueAndAssert "Hello, World!"
+            updateValueAndAssert 12345
+            updateValueAndAssert [ 1; 2; 3; 4; 5 ]
diff --git a/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs b/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
index 8f7a9acb..4823eed0 100644
--- a/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/StyledElement.fs
@@ -269,6 +269,31 @@ module StyledElement =
 
             AttrBuilder<'t>.CreateContentSingle(name, ValueSome getter, ValueSome setter,singleContent)
 
+        /// <summary>
+        /// Create subscription from `StyledElement.GetResourceObservable`.
+        /// </summary>
+        /// <remarks>
+        /// - Observation result is wrapped in `option` type: `None` for `null` or `AvaloniaProperty.UnsetValue`, `Some value` otherwise.
+        /// </remarks>
+        static member onResourceObservable<'t when 't :> StyledElement>(key: obj, func: obj option -> unit, ?subPatchOptions) : IAttr<'t> =
+            let name = $"{typeof<'t>.Name}.ResourceObservable.{key}"
+
+            let factory: SubscriptionFactory<obj option> =
+                fun (control, func, token) ->
+                    let callback (v: obj) =
+                        match v with
+                        | null -> None
+                        | v when v = AvaloniaProperty.UnsetValue -> None
+                        | _ -> Some v
+                        |> func
+
+                    let subscription =
+                        (control :?> 't).GetResourceObservable(key).Subscribe(callback)
+
+                    token.Register(fun () -> subscription.Dispose()) |> ignore
+            
+            AttrBuilder<'t>.CreateSubscription<obj option>(name, factory, func, ?subPatchOptions = subPatchOptions)
+
         // Attached properties related to text input
         
         static member contentType<'t when 't :> StyledElement>(value) : IAttr<'t> =

From 9458df93d10b3a4c197bcd36df7ecf0e8379c5cf Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 15 Nov 2025 09:16:49 +0900
Subject: [PATCH 10/18] fix: Correct typos in documentation and error messages
 for Routed Event subscriptions and ResourceProvider

---
 src/Avalonia.FuncUI/DSL/AttrBuilder.fs           | 9 +++++----
 src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs | 2 +-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.FuncUI/DSL/AttrBuilder.fs b/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
index 01c77a26..86b2ace1 100644
--- a/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
+++ b/src/Avalonia.FuncUI/DSL/AttrBuilder.fs
@@ -277,17 +277,18 @@ type AttrBuilder<'view>() =
         }
         attr :> IAttr<'view>
 
-     /// <summary>
+    /// <summary>
     /// Create a Routed Event Subscription Attribute for a Routed Event
     /// </summary>
+    /// <exception cref="System.InvalidOperationException">Thrown if `'view` is not derived from Interactive.</exception>
     static member CreateSubscription<'arg when 'arg :> RoutedEventArgs>
       ( routedEvent: RoutedEvent<'arg>,
         func: 'arg -> unit,
         ?subPatchOptions: SubPatchOptions ) : IAttr<'view> =
-        let isValiedViewType =
+        let isValidViewType =
           typeof<'view>.IsAssignableTo(typeof<Interactive>)
-        if not isValiedViewType then
-          invalidOp $"{nameof<'view>} con't create RoutedEvent subscriptions. It must be derived from Interactive."
+        if not isValidViewType then
+          invalidOp $"{nameof<'view>} can't create RoutedEvent subscriptions. It must be derived from Interactive."
 
         // subscribe to avalonia property
         // TODO: extract to helpers module
diff --git a/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs b/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs
index 36c362bd..ec2f5ad4 100644
--- a/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs
+++ b/src/Avalonia.FuncUI/DSL/Base/ResourceProvider.fs
@@ -13,7 +13,7 @@ module ResourceProvider =
         /// Create subscription from `'view.GetResourceObservable`.
         /// </summary>
         /// <remarks>
-        /// - If `'view.Orner` is `null`, `func` is never called.
+        /// - If `'view.Owner` is `null`, `func` is never called.
         /// - Observation result is wrapped in `option` type: `None` for `null` or `AvaloniaProperty.UnsetValue`, `Some value` otherwise.
         /// </remarks>
         static member onResourceObservable<'t when 't :> ResourceProvider>

From 02b7700dc2fe67bc68171c679207a6435c47ffca Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 15 Nov 2025 11:43:00 +0900
Subject: [PATCH 11/18] refactor: Simplify ResourceDictionary.keyValue test
 assertions with helper functions

---
 .../DSL/Base/ResourceDictionaryTests.fs       | 45 ++++++++++---------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 74bfcddc..40e65bee 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -66,28 +66,29 @@ module ResourceDictionaryTests =
 
             Assert.ResourceDictionary.containsKeyAndValueEqual target key initialValue
 
-            List.fold
-                (fun lastView acc ->
-                    match acc with
-                    | Choice1Of2(nextValue: obj) ->
-                        let updatedView = createView nextValue
-                        VirtualDom.update target lastView updatedView
-                        Assert.ResourceDictionary.containsKeyAndValueEqual target key nextValue
-                        updatedView
-                    | Choice2Of2(nextValue, expected, converter) ->
-                        let updatedView = createViewWithIView nextValue
-                        VirtualDom.update target lastView updatedView
-                        Assert.ResourceDictionary.containsKeyAndValueEqualWith target key expected converter
-                        updatedView)
-                initView
-                [ Choice1Of2 42
-                  Choice1Of2 "a string"
-                  Choice1Of2 null
-                  Choice1Of2 3.14
-                  Choice2Of2(TextBlock.create [ TextBlock.text "Hello" ], "Hello", fun o -> (o :?> TextBlock).Text)
-                  Choice1Of2 true
-                  Choice1Of2(TextBox(Text = "Hello, World!"))
-                  Choice1Of2(ContentControl(Content = Button(Content = "Click Me"))) ]
+            let updateAndAssertObj value currentView =
+                let updatedView = createView value
+                VirtualDom.update target currentView updatedView
+                Assert.ResourceDictionary.containsKeyAndValueEqual target key value
+                updatedView
+            
+            let updateAndAssertIView value expected converter currentView =
+                let updatedView = createViewWithIView value
+                VirtualDom.update target currentView updatedView
+                Assert.ResourceDictionary.containsKeyAndValueEqualWith target key expected converter
+                updatedView
+            
+            initView
+            |> updateAndAssertObj 42
+            |> updateAndAssertObj "a string"
+            |> updateAndAssertIView (Button.create [ Button.content "Click Me" ]) "Click Me" (fun o -> (o :?> Button).Content :?> string)
+            |> updateAndAssertObj null
+            |> updateAndAssertObj 3.14
+            |> updateAndAssertIView (TextBlock.create [ TextBlock.text "Hello" ]) "Hello" (fun o -> (o :?> TextBlock).Text)
+            |> updateAndAssertObj true
+            |> updateAndAssertObj (TextBox(Text = "Hello, World!"))
+            |> updateAndAssertObj (ContentControl(Content = Button(Content = "Click Me")))
+            |> ignore
 
 
         [<Fact>]

From 8b4f92af7fa74eb4d1f8e95b49b877e7357dd49d Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 15 Nov 2025 15:03:58 +0900
Subject: [PATCH 12/18] refactor: Introduce Avalonia.Headless.XUnit package

Migrated from manual session management with custom code using only Avalonia.Headless
to framework-managed approach with Avalonia.Headless.XUnit, resolving "Call from invalid thread"
errors and test hanging issues.

- Add Avalonia.Headless.XUnit package reference
- Change UI thread accessing tests to use [AvaloniaFact] attribute
- Remove unnecessary manual session management code

Note: Avalonia.Headless was initially introduced in commit 3c6723185e315ea958799bcac93d29828b699d63
to implement tests containing XAML code.
---
 .../Avalonia.FuncUI.UnitTests.fsproj          |   1 +
 .../DSL/Base/ResourceDictionaryTests.fs       | 114 +++++++++---------
 .../DSL/Base/StyledElementTests.fs            |  25 ++--
 .../DSL/TestHelpers.fs                        |  27 ++---
 .../VirtualDom/VirtualDom.DifferTests.fs      |   5 +-
 .../VirtualDom/VirtualDom.ModuleTests.fs      |  11 +-
 .../VirtualDom/VirtualDom.PatcherTests.fs     |  11 +-
 7 files changed, 96 insertions(+), 98 deletions(-)

diff --git a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
index bc913438..2bd36715 100644
--- a/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
+++ b/src/Avalonia.FuncUI.UnitTests/Avalonia.FuncUI.UnitTests.fsproj
@@ -29,6 +29,7 @@
 
   <ItemGroup>
     <PackageReference Include="Avalonia.Headless" Version="$(AvaloniaVersion)" />
+    <PackageReference Include="Avalonia.Headless.Xunit" Version="$(AvaloniaVersion)" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
     <PackageReference Include="System.Reactive" Version="6.0.1" />
     <PackageReference Include="xunit" Version="2.9.0" />
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
index 40e65bee..18a6eda9 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/ResourceDictionaryTests.fs
@@ -2,6 +2,7 @@ namespace Avalonia.FuncUI.UnitTests.DSL
 
 open Avalonia
 open Avalonia.Controls
+open Avalonia.Headless.XUnit
 open global.Xunit
 
 module ResourceDictionaryTests =
@@ -9,7 +10,7 @@ module ResourceDictionaryTests =
 
     module ``keyValue`` =
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set`` () =
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
@@ -31,7 +32,7 @@ module ResourceDictionaryTests =
 
             Assert.ResourceDictionary.notContainsKey target key
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set null value`` () =
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
@@ -50,7 +51,7 @@ module ResourceDictionaryTests =
             Assert.ResourceDictionary.notContainsKey target key
 
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can update value`` () =
             let key = "myKey"
 
@@ -71,27 +72,29 @@ module ResourceDictionaryTests =
                 VirtualDom.update target currentView updatedView
                 Assert.ResourceDictionary.containsKeyAndValueEqual target key value
                 updatedView
-            
+
             let updateAndAssertIView value expected converter currentView =
                 let updatedView = createViewWithIView value
                 VirtualDom.update target currentView updatedView
                 Assert.ResourceDictionary.containsKeyAndValueEqualWith target key expected converter
                 updatedView
-            
+
             initView
             |> updateAndAssertObj 42
             |> updateAndAssertObj "a string"
-            |> updateAndAssertIView (Button.create [ Button.content "Click Me" ]) "Click Me" (fun o -> (o :?> Button).Content :?> string)
+            |> updateAndAssertIView (Button.create [ Button.content "Click Me" ]) "Click Me" (fun o ->
+                (o :?> Button).Content :?> string)
             |> updateAndAssertObj null
             |> updateAndAssertObj 3.14
-            |> updateAndAssertIView (TextBlock.create [ TextBlock.text "Hello" ]) "Hello" (fun o -> (o :?> TextBlock).Text)
+            |> updateAndAssertIView (TextBlock.create [ TextBlock.text "Hello" ]) "Hello" (fun o ->
+                (o :?> TextBlock).Text)
             |> updateAndAssertObj true
             |> updateAndAssertObj (TextBox(Text = "Hello, World!"))
             |> updateAndAssertObj (ContentControl(Content = Button(Content = "Click Me")))
             |> ignore
 
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can update key`` () =
             let initialKey = "initialKey"
             let updatedKey = "updatedKey"
@@ -113,7 +116,7 @@ module ResourceDictionaryTests =
             Assert.ResourceDictionary.containsKeyAndValueEqual target updatedKey value
 
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set multiple`` () =
             let key1 = "key1"
             let value1 = "value1"
@@ -148,7 +151,7 @@ module ResourceDictionaryTests =
             Assert.ResourceDictionary.notContainsKey target key1
             Assert.ResourceDictionary.notContainsKey target key2
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set with IView`` () =
             let assertResourceTextEquals dict key expectedText =
                 Assert.ResourceDictionary.containsKeyAndValueEqualWith dict key expectedText (fun o ->
@@ -184,7 +187,7 @@ module ResourceDictionaryTests =
 
             Assert.ResourceDictionary.notContainsKey target key
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``with object creates new instance on update`` () =
             let key = "myKey"
             let text = "TextBlock Text"
@@ -209,7 +212,7 @@ module ResourceDictionaryTests =
             Assert.NotEqual(initialTextBlock, updatedTextBlock)
             Assert.Equal(text, updatedTextBlock.Text)
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``with IView reuses existing instance when patchable`` () =
             let key = "myKey"
             let initialText = "Initial Text"
@@ -240,7 +243,7 @@ module ResourceDictionaryTests =
         open System
         open Avalonia.Media
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set merged dictionaries`` () =
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
@@ -259,7 +262,7 @@ module ResourceDictionaryTests =
             Assert.ResourceDictionary.containsKeyAndValueEqual target "key1" "value1"
             Assert.ResourceDictionary.containsKeyAndValueEqual target "key2" "value2"
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``TryGetResource should find resource from later merged dictionary`` () =
             let initView = ResourceDictionary.create []
             let target = VirtualDom.create initView
@@ -279,62 +282,61 @@ module ResourceDictionaryTests =
 
             Assert.ResourceDictionary.containsKeyAndValueEqual target sameKey "valueFromDict2"
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can add ResourcesInclude to merged dictionaries`` () =
-            Headless.dispatch (fun () ->
-                let initView = ResourceDictionary.create []
-                let target = VirtualDom.create initView
-                let host = StyledElement()
-                host.Resources <- target
+            let initView = ResourceDictionary.create []
+            let target = VirtualDom.create initView
+            let host = StyledElement()
+            host.Resources <- target
 
-                let assertResources kv =
-                    for (key, color) in kv do
-                        let brush =
-                            Assert.ResourceDictionary.containsKey target key
-                            |> Assert.IsType<SolidColorBrush>
+            let assertResources kv =
+                for (key, color) in kv do
+                    let brush =
+                        Assert.ResourceDictionary.containsKey target key
+                        |> Assert.IsType<SolidColorBrush>
 
-                        Assert.Equal(color, brush.Color)
+                    Assert.Equal(color, brush.Color)
 
-                let include1 =
-                    ResourceInclude.fromUri (new Uri("avares://Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml"))
+            let include1 =
+                ResourceInclude.fromUri (new Uri("avares://Avalonia.FuncUI.UnitTests/Assets/TestResources1.xaml"))
 
-                let updatedView =
-                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1 ] ]
+            let updatedView =
+                ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1 ] ]
 
-                VirtualDom.update target initView updatedView
+            VirtualDom.update target initView updatedView
 
-                let include1KeyValues =
-                    [ ("BrushA", Colors.Red); ("BrushB", Colors.Green); ("BrushC", Colors.Blue) ]
+            let include1KeyValues =
+                [ ("BrushA", Colors.Red); ("BrushB", Colors.Green); ("BrushC", Colors.Blue) ]
 
-                // Assert initial resources from include1
-                assertResources include1KeyValues
+            // Assert initial resources from include1
+            assertResources include1KeyValues
 
-                let include2 =
-                    ResourceInclude.fromString "avares://Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml"
+            let include2 =
+                ResourceInclude.fromString "avares://Avalonia.FuncUI.UnitTests/Assets/TestResources2.xaml"
 
-                // Add another ResourceInclude
-                let updatedView2 =
-                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1; include2 ] ]
+            // Add another ResourceInclude
+            let updatedView2 =
+                ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include1; include2 ] ]
 
-                VirtualDom.update target updatedView updatedView2
+            VirtualDom.update target updatedView updatedView2
 
-                let include2KeyValues =
-                    [ ("BrushA", Colors.White); ("BrushB", Colors.Black); ("BrushC", Colors.Gray) ]
+            let include2KeyValues =
+                [ ("BrushA", Colors.White); ("BrushB", Colors.Black); ("BrushC", Colors.Gray) ]
 
-                // Now the values should come from include2
-                assertResources include2KeyValues
+            // Now the values should come from include2
+            assertResources include2KeyValues
 
-                // Switch the order of includes
-                let updatedView3 =
-                    ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include2; include1 ] ]
+            // Switch the order of includes
+            let updatedView3 =
+                ResourceDictionary.create [ ResourceDictionary.mergedDictionaries [ include2; include1 ] ]
 
-                VirtualDom.update target updatedView2 updatedView3
+            VirtualDom.update target updatedView2 updatedView3
 
-                // Now the values should come from include1 again
-                assertResources include1KeyValues)
+            // Now the values should come from include1 again
+            assertResources include1KeyValues
 
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``TryGetResource should find itself before merged dictionaries`` () =
         let initView = ResourceDictionary.create []
         let target = VirtualDom.create initView
@@ -354,7 +356,7 @@ module ResourceDictionaryTests =
     module ``themeDictionariesKeyValue`` =
         open Avalonia.Styling
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set theme dictionaries key value`` () =
             let key = "themeKey"
             let darkValue = "darkValue"
@@ -380,7 +382,7 @@ module ResourceDictionaryTests =
     module ``onResourceObservable`` =
         open Avalonia.Styling
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``when Owner is not set, callback is not fired`` () =
             let key = "observableKey"
             let value = "observableValue"
@@ -400,7 +402,7 @@ module ResourceDictionaryTests =
             Assert.False(isCalled, "Callback was unexpectedly called when Owner is not set.")
 
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``when Owner is set, callback is fired`` () =
             let target = ResourceDictionary()
             let host = StyledElement()
@@ -443,7 +445,7 @@ module ResourceDictionaryTests =
             // Notification after update
             Assert.Equal(Some(box updatedValue), observedValue)
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``defaultThemeVariant tests`` () =
             let target = ResourceDictionary()
             let host = StyledElement()
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
index 10d03b57..328e27e6 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/Base/StyledElementTests.fs
@@ -2,6 +2,7 @@ namespace Avalonia.FuncUI.UnitTests.DSL
 
 open Avalonia
 open Avalonia.Controls
+open Avalonia.Headless.XUnit
 open global.Xunit
 
 module StyledElementTests =
@@ -20,7 +21,7 @@ module StyledElementTests =
     module ``classes`` =
         open Avalonia.FuncUI.VirtualDom
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with string list`` () =
             let valueList () = [ "class1"; "class2" ]
 
@@ -32,7 +33,7 @@ module StyledElementTests =
 
             Assert.Empty stringList
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with same classes instance`` () =
             let classes = Classes()
             classes.Add "class1"
@@ -43,7 +44,7 @@ module StyledElementTests =
 
             Assert.Empty sameClassesInstance
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with different classes instance`` () =
             let classes1 = Classes()
             classes1.Add "class1"
@@ -67,7 +68,7 @@ module StyledElementTests =
             s.Setters.Add(Setter(Control.TagProperty, "foo"))
             s :> IStyle
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with style list has same style instance`` () =
             let style = initStyle ()
 
@@ -82,7 +83,7 @@ module StyledElementTests =
             Assert.Empty styleList
 
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with style list has different style instance`` () =
 
             let style1 = initStyle ()
@@ -102,7 +103,7 @@ module StyledElementTests =
 
             | _ -> Assert.Fail $"Not expected delta\n{styleList}"
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with Styles property has same instance`` () =
             let style = initStyle ()
 
@@ -117,7 +118,7 @@ module StyledElementTests =
 
             Assert.Empty styleList
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with Styles property has different Styles instance has same style instance`` () =
             let style = initStyle ()
 
@@ -134,7 +135,7 @@ module StyledElementTests =
 
             Assert.Empty styleList
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``equality with Styles property has different Styles instance has different style instance`` () =
             let style1 = initStyle ()
             let style2 = initStyle ()
@@ -165,7 +166,7 @@ module StyledElementTests =
             Assert.True isFound
             Assert.IsType<'t>(resValue)
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``con set empty dictionary`` () =
             let initView =
                 StyledElement.create [ StyledElement.resources (ResourceDictionary.create []) ]
@@ -174,7 +175,7 @@ module StyledElementTests =
 
             Assert.False target.Resources.HasResources
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can set dictionary with values`` () =
             let initView =
                 StyledElement.create
@@ -193,7 +194,7 @@ module StyledElementTests =
             Assert.Equal("value1", assertResource "key1")
             Assert.Equal(42, assertResource "key2")
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``can update dictionary`` () =
             let initView =
                 StyledElement.create
@@ -217,7 +218,7 @@ module StyledElementTests =
 
     module ``onResourceObservable`` =
 
-        [<Fact>]
+        [<AvaloniaFact>]
         let ``observes resource changes with multiple types`` () =
             let mutable observedValue: obj option = Some(box "no value changed.")
             let callback v = observedValue <- v
diff --git a/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs b/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs
index 4227115a..83e9a643 100644
--- a/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs
+++ b/src/Avalonia.FuncUI.UnitTests/DSL/TestHelpers.fs
@@ -1,25 +1,16 @@
 namespace Avalonia.FuncUI.UnitTests.DSL
 
 open Avalonia
+open Avalonia.Headless
 
-module Headless =
-    open System
-    open System.Threading
-    open System.Threading.Tasks
-    open Avalonia.Headless
+type TestAppBuilder() =
+    static member BuildAvaloniaApp() =
+        AppBuilder.Configure<Application>()
+            .UseHeadless(new AvaloniaHeadlessPlatformOptions())
 
-    let useSession () =
-        typeof<Application> |> HeadlessUnitTestSession.StartNew
-
-    let dispatch fn =
-        use session = useSession ()
-        let action = Action fn
-        session.Dispatch(action, CancellationToken.None)
-
-    let dispatchAsync fn =
-        use session = useSession ()
-        let action = Func<Task>(fun () -> fn)
-        session.Dispatch(action, CancellationToken.None)
+// Registers the test application builder for all tests in this assembly
+[<assembly: AvaloniaTestApplication(typeof<TestAppBuilder>)>]
+do ()
 
 module VirtualDom =
     open Avalonia.FuncUI.VirtualDom
@@ -92,4 +83,4 @@ module Assert =
             Assert.Equal(expectedValue, converter actualValue)
 
         let containsKeyAndValueEqual (dict: ResourceDictionary) (key: 'k) (expectedValue: 'v) =
-            containsKeyAndValueEqualWith dict key expectedValue (fun o -> o :?> 'v)
\ No newline at end of file
+            containsKeyAndValueEqualWith dict key expectedValue (fun o -> o :?> 'v)
diff --git a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.DifferTests.fs b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.DifferTests.fs
index bb45a79d..7eff5c4a 100644
--- a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.DifferTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.DifferTests.fs
@@ -5,6 +5,7 @@ module DifferTests =
     open Avalonia.FuncUI.Types
     open Avalonia.FuncUI.VirtualDom
     open Avalonia.Controls
+    open Avalonia.Headless.XUnit
     open Xunit
     open Avalonia.Layout
     open Avalonia.Media
@@ -77,7 +78,7 @@ module DifferTests =
         // just to make sure the types are actually comparable
         Assert.True(not (delta <> result))
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Diff Content Single`` () =
         let last =
             Button.create [
@@ -146,7 +147,7 @@ module DifferTests =
         // just to make sure the types are actually comparable
         Assert.True(not (delta <> result))
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Diff Content Multiple`` () =
         let last =
             StackPanel.create [
diff --git a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.ModuleTests.fs b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.ModuleTests.fs
index ef5df9cf..4ab4791b 100644
--- a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.ModuleTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.ModuleTests.fs
@@ -9,10 +9,11 @@ module ModuleTests =
     open Avalonia.FuncUI.VirtualDom
     open Avalonia.FuncUI.DSL
     open Avalonia.FuncUI
+    open Avalonia.Headless.XUnit
     open Xunit
     open System
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``integration test 1`` () =
         let view =
             StackPanel.create [
@@ -65,7 +66,7 @@ module ModuleTests =
         Assert.Equal(Nullable(true), (stackpanel.Children.[2] :?> CheckBox).IsChecked)
         ()
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``integration test 2`` () =
         let view =
             StackPanel.create [
@@ -147,7 +148,7 @@ module ModuleTests =
         Assert.Equal(Nullable(false), (stackpanel.Children.[2] :?> CheckBox).IsChecked)
         ()
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``integration test 'VirtualDom.updateRoot' (from null to Button to TextBlock)`` () =
         let view : IView =
             Button.create [
@@ -179,7 +180,7 @@ module ModuleTests =
         ()
 
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``integration test 'VirtualDom.updateRoot' (from null to Button to null)`` () =
         let view : IView =
             Button.create [
@@ -202,7 +203,7 @@ module ModuleTests =
         Assert.Equal(null, host.Content)
         ()
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``integration test 'VirtualDom.updateRoot' (reuse/patch button)`` () =
         let view : IView =
             Button.create [
diff --git a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.PatcherTests.fs b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.PatcherTests.fs
index dfde9170..dd208a22 100644
--- a/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.PatcherTests.fs
+++ b/src/Avalonia.FuncUI.UnitTests/VirtualDom/VirtualDom.PatcherTests.fs
@@ -13,9 +13,10 @@ module PatcherTests =
     open Avalonia.FuncUI.DSL
     open Avalonia.FuncUI.Types
     open Avalonia.FuncUI.VirtualDom
+    open Avalonia.Headless.XUnit
     open Xunit
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Patch Properties`` () =
 
         let delta : Delta.ViewDelta =
@@ -45,7 +46,7 @@ module PatcherTests =
         Assert.Equal("some text", control.Text)
         Assert.Equal(14.0, control.FontSize)
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Patch Styles, Classes or Resources`` () =
         let stylesGetter: AvaloniaObject -> obj = (fun c -> (c :?> StyledElement).Styles :> obj)
         let stylesSetter: AvaloniaObject * obj -> unit =
@@ -112,7 +113,7 @@ module PatcherTests =
         Assert.Equal(0, control.Classes.Count)
         Assert.Equal(0, control.Resources.Count)
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Patch Content Single`` () =
 
         let delta : Delta.ViewDelta =
@@ -159,7 +160,7 @@ module PatcherTests =
         Assert.Equal("some text", textblock.Text)
         Assert.Equal(15.0, textblock.FontSize)
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Patch Content Multiple`` () =
         let delta : Delta.ViewDelta =
             {
@@ -252,7 +253,7 @@ module PatcherTests =
         let button = stackpanel.Children.[2] :?> Button
         Assert.Equal(SolidColorBrush.Parse("green").ToImmutable() :> IBrush, button.Background)
 
-    [<Fact>]
+    [<AvaloniaFact>]
     let ``Patch Custom Subscription`` () =
         /// Capture list for factory called.
         let factoryCaptures = ResizeArray()

From fd6947f058452d81e3303c70f66513439f3caa68 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Wed, 19 Nov 2025 09:34:39 +0900
Subject: [PATCH 13/18] [wip] Create ResourceDictionary Sample Project.

---
 src/Avalonia.FuncUI.sln                       |   7 ++
 .../Examples.ThemeSwitcher/.editorconfig      |  10 ++
 .../Assets/Icons/icon.ico                     | Bin 0 -> 165662 bytes
 .../Examples.ThemeSwitcher/DSL/ColorPicker.fs |   9 ++
 .../Examples.ThemeSwitcher/DSL/ColorView.fs   | 103 ++++++++++++++++++
 .../Examples.ThemeSwitcher.fsproj             |  27 +++++
 src/Examples/Examples.ThemeSwitcher/Main.fs   |  93 ++++++++++++++++
 .../Examples.ThemeSwitcher/Program.fs         |  41 +++++++
 8 files changed, 290 insertions(+)
 create mode 100644 src/Examples/Examples.ThemeSwitcher/.editorconfig
 create mode 100644 src/Examples/Examples.ThemeSwitcher/Assets/Icons/icon.ico
 create mode 100644 src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
 create mode 100644 src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
 create mode 100644 src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
 create mode 100644 src/Examples/Examples.ThemeSwitcher/Main.fs
 create mode 100644 src/Examples/Examples.ThemeSwitcher/Program.fs

diff --git a/src/Avalonia.FuncUI.sln b/src/Avalonia.FuncUI.sln
index 137bfe25..e254eca7 100644
--- a/src/Avalonia.FuncUI.sln
+++ b/src/Avalonia.FuncUI.sln
@@ -86,6 +86,8 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Examples.SettingFocus", "Ex
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Examples.Experimental.ViewModelComponent.CounterApp", "Examples\Experimental\Examples.Experimental.ViewModelComponent.CounterApp\Examples.Experimental.ViewModelComponent.CounterApp.fsproj", "{C59DF473-A6F9-4D94-9308-9381F36CB71D}"
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Examples.ThemeSwitcher", "Examples\Examples.ThemeSwitcher\Examples.ThemeSwitcher.fsproj", "{533F366D-43DC-4E30-A2BD-684385C6D499}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -208,6 +210,10 @@ Global
 		{C59DF473-A6F9-4D94-9308-9381F36CB71D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C59DF473-A6F9-4D94-9308-9381F36CB71D}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C59DF473-A6F9-4D94-9308-9381F36CB71D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{533F366D-43DC-4E30-A2BD-684385C6D499}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{533F366D-43DC-4E30-A2BD-684385C6D499}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{533F366D-43DC-4E30-A2BD-684385C6D499}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{533F366D-43DC-4E30-A2BD-684385C6D499}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -243,6 +249,7 @@ Global
 		{2C7F4542-65CE-4EC6-9876-C1C2215EE006} = {84811DB3-C276-4F0D-B3BA-78B88E2C6EF0}
 		{70BDCE72-149A-435A-9910-E79DE329F978} = {84811DB3-C276-4F0D-B3BA-78B88E2C6EF0}
 		{C59DF473-A6F9-4D94-9308-9381F36CB71D} = {24AD0B82-9D10-4929-8FFE-E5E048C11842}
+		{533F366D-43DC-4E30-A2BD-684385C6D499} = {84811DB3-C276-4F0D-B3BA-78B88E2C6EF0}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {4630E817-6780-4C98-9379-EA3B45224339}
diff --git a/src/Examples/Examples.ThemeSwitcher/.editorconfig b/src/Examples/Examples.ThemeSwitcher/.editorconfig
new file mode 100644
index 00000000..0b6da013
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/.editorconfig
@@ -0,0 +1,10 @@
+[*.fs]
+fsharp_space_before_uppercase_invocation = true
+
+# Write a comment by starting the line with a '#'
+[*.{fs,fsx,fsi}]
+fsharp_bar_before_discriminated_union_declaration = true
+
+# Apply specific settings for a targeted subfolder
+[Main.fs]
+fsharp_experimental_elmish = true
\ No newline at end of file
diff --git a/src/Examples/Examples.ThemeSwitcher/Assets/Icons/icon.ico b/src/Examples/Examples.ThemeSwitcher/Assets/Icons/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..9fd305d05014179e7bf7ac901042d0e2e2fa7d8e
GIT binary patch
literal 165662
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

literal 0
HcmV?d00001

diff --git a/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
new file mode 100644
index 00000000..e5ab8ca6
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
@@ -0,0 +1,9 @@
+namespace Examples.ThemeSwitcher.DSL
+
+open Avalonia.Controls
+open Avalonia.FuncUI.Types
+
+module ColorPicker =
+    open Avalonia.FuncUI.DSL
+
+    let create (attrs: IAttr<ColorPicker> list) : IView<ColorPicker> = ViewBuilder.Create<ColorPicker> (attrs)
diff --git a/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs b/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
new file mode 100644
index 00000000..f45cd1e4
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
@@ -0,0 +1,103 @@
+namespace Examples.ThemeSwitcher.DSL
+
+open Avalonia.Controls
+open Avalonia.FuncUI.Types
+
+[<AutoOpen>]
+module ColorViewDSL =
+    open Avalonia.FuncUI.Builder
+    open Avalonia.Media
+
+    type ColorView with
+
+        static member color<'t when 't :> ColorView>(color: Color) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<Color> (ColorView.ColorProperty, color, ValueNone)
+
+        static member colorModel<'t when 't :> ColorView>(colorModel: ColorModel) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<ColorModel> (ColorView.ColorModelProperty, colorModel, ValueNone)
+
+        static member colorSpectrumComponents<'t when 't :> ColorView>
+            (components: ColorSpectrumComponents)
+            : IAttr<'t> =
+            AttrBuilder<'t>
+                .CreateProperty<ColorSpectrumComponents> (
+                    ColorView.ColorSpectrumComponentsProperty,
+                    components,
+                    ValueNone
+                )
+
+        static member colorSpectrumShape<'t when 't :> ColorView>(shape: ColorSpectrumShape) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<ColorSpectrumShape> (ColorView.ColorSpectrumShapeProperty, shape, ValueNone)
+
+        static member hexInputAlphaPosition<'t when 't :> ColorView>(position: AlphaComponentPosition) : IAttr<'t> =
+            AttrBuilder<'t>
+                .CreateProperty<AlphaComponentPosition> (ColorView.HexInputAlphaPositionProperty, position, ValueNone)
+
+        static member hsvColor<'t when 't :> ColorView>(hsvColor: HsvColor) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<HsvColor> (ColorView.HsvColorProperty, hsvColor, ValueNone)
+
+        static member isAccentColorsVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAccentColorsVisibleProperty, value, ValueNone)
+
+        static member isAlphaEnabled<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAlphaEnabledProperty, value, ValueNone)
+
+        static member isAlphaVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAlphaVisibleProperty, value, ValueNone)
+
+        static member isColorComponentsVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorComponentsVisibleProperty, value, ValueNone)
+
+        static member isColorModelVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorModelVisibleProperty, value, ValueNone)
+
+        static member isColorPaletteVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorPaletteVisibleProperty, value, ValueNone)
+
+        static member isColorPreviewVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorPreviewVisibleProperty, value, ValueNone)
+
+        static member isColorSpectrumVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorSpectrumVisibleProperty, value, ValueNone)
+
+        static member isColorSpectrumSliderVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorSpectrumSliderVisibleProperty, value, ValueNone)
+
+        static member isComponentSliderVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsComponentSliderVisibleProperty, value, ValueNone)
+
+        static member isComponentTextInputVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsComponentTextInputVisibleProperty, value, ValueNone)
+
+        static member isHexInputVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsHexInputVisibleProperty, value, ValueNone)
+
+        static member maxHue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxHueProperty, value, ValueNone)
+
+        static member maxSaturation<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxSaturationProperty, value, ValueNone)
+
+        static member maxValue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxValueProperty, value, ValueNone)
+
+        static member minHue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinHueProperty, value, ValueNone)
+
+        static member minSaturation<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinSaturationProperty, value, ValueNone)
+
+        static member minValue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinValueProperty, value, ValueNone)
+
+        static member paletteColors<'t when 't :> ColorView>(value: seq<Color>) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<seq<Color>> (ColorView.PaletteColorsProperty, value, ValueNone)
+
+        static member paletteColumnCount<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.PaletteColumnCountProperty, value, ValueNone)
+
+        static member palette<'t when 't :> ColorView>(value: IColorPalette) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<IColorPalette> (ColorView.PaletteProperty, value, ValueNone)
+
+        static member selectedIndex<'t when 't :> ColorView>(value: int) : IAttr<'t> =
+            AttrBuilder<'t>.CreateProperty<int> (ColorView.SelectedIndexProperty, value, ValueNone)
diff --git a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
new file mode 100644
index 00000000..234eb2cb
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <RootNamespace>Examples.ThemeSwitcher</RootNamespace>
+        <PackageId>Examples.ThemeSwitcher</PackageId>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Content Include="Assets\Icons\icon.ico">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </Content>
+        <Compile Include="DSL/ColorView.fs" />
+        <Compile Include="DSL/ColorPicker.fs" />
+        <Compile Include="Main.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
+        <PackageReference Include="Avalonia.Themes.Fluent" Version="$(AvaloniaVersion)" />
+        <PackageReference Include="Avalonia.Controls.ColorPicker" Version="$(AvaloniaVersion)" />
+        <ProjectReference Include="..\..\Avalonia.FuncUI\Avalonia.FuncUI.fsproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/src/Examples/Examples.ThemeSwitcher/Main.fs b/src/Examples/Examples.ThemeSwitcher/Main.fs
new file mode 100644
index 00000000..baadaa71
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/Main.fs
@@ -0,0 +1,93 @@
+namespace Examples.ThemeSwitcher
+
+module Main =
+    open Avalonia
+    open Avalonia.Controls
+    open Avalonia.Media
+    open Avalonia.FuncUI
+    open Avalonia.FuncUI.DSL
+    open Avalonia.FuncUI.Types
+    open Avalonia.Styling
+    open Examples.ThemeSwitcher.DSL
+
+
+    module ThemeVariant =
+        let Custom = ThemeVariant ("Custom", ThemeVariant.Dark)
+
+    /// Define Custom ThemeVariant's Colors.
+    type State =
+        { PrimaryBrushColor: Color
+          SecondaryBrushColor: Color
+          BackgroundBrushColor: Color
+          SurfaceBrushColor: Color
+          TextBrushColor: Color
+          AccentBrushColor: Color }
+
+    /// Initial state with default colors.
+    let init =
+        { PrimaryBrushColor = Colors.RoyalBlue
+          SecondaryBrushColor = Colors.SteelBlue
+          BackgroundBrushColor = Colors.White
+          SurfaceBrushColor = Color.Parse ("#F3F3F3")
+          TextBrushColor = Colors.Black
+          AccentBrushColor = Colors.Blue }
+
+    // Create theme-specific resources
+    let createThemeResources (state: State) : IView =
+        ResourceDictionary.create [
+            // Common resources used by all themes
+            ResourceDictionary.keyValue ("LargeFontSize", 24.0)
+            ResourceDictionary.keyValue ("MediumFontSize", 16.0)
+            ResourceDictionary.keyValue ("SmallFontSize", 12.0)
+            ResourceDictionary.keyValue ("DefaultPadding", Thickness (16.0))
+            ResourceDictionary.keyValue ("ButtonPadding", Thickness (12.0, 8.0))
+
+            // Theme variant-specific resources
+            ResourceDictionary.themeDictionariesKeyValue (
+                ThemeVariant.Dark,
+                ResourceDictionary.create [
+                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (Colors.CornflowerBlue))
+                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (Colors.LightSteelBlue))
+                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (Color.Parse ("#1E1E1E")))
+                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (Color.Parse ("#252526")))
+                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (Colors.White))
+                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (Colors.DodgerBlue))
+                ]
+            )
+
+            ResourceDictionary.themeDictionariesKeyValue (
+                ThemeVariant.Light,
+                ResourceDictionary.create [
+                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (Colors.RoyalBlue))
+                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (Colors.SteelBlue))
+                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (Colors.White))
+                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (Color.Parse ("#F3F3F3")))
+                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (Colors.Black))
+                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (Colors.Blue))
+                ]
+            )
+
+            ResourceDictionary.themeDictionariesKeyValue (
+                ThemeVariant.Custom,
+                ResourceDictionary.create [
+                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (state.PrimaryBrushColor))
+                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (state.SecondaryBrushColor))
+                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (state.BackgroundBrushColor))
+                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (state.SurfaceBrushColor))
+                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (state.TextBrushColor))
+                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (state.AccentBrushColor))
+                ]
+            )
+        ]
+    
+    let colorPickerView (color:Color) =
+        ColorPicker.create []
+
+    let view () =
+        Component (fun ctx ->
+
+            Grid.create [
+                Grid.rowDefinitions "Auto,Auto"
+                Grid.columnDefinitions "*,*"
+                Grid.children [ ColorPicker.create [] ]
+            ])
diff --git a/src/Examples/Examples.ThemeSwitcher/Program.fs b/src/Examples/Examples.ThemeSwitcher/Program.fs
new file mode 100644
index 00000000..e018b435
--- /dev/null
+++ b/src/Examples/Examples.ThemeSwitcher/Program.fs
@@ -0,0 +1,41 @@
+namespace Examples.ThemeSwitcher
+
+open Avalonia
+open Avalonia.Controls
+open Avalonia.Controls.ApplicationLifetimes
+open Avalonia.Themes.Fluent
+open Avalonia.FuncUI
+open Avalonia.FuncUI.Hosts
+open Avalonia.Markup.Xaml.Styling
+
+type MainWindow() =
+    inherit HostWindow()
+
+    do
+        base.Title <- "Theme Switcher Example"
+        base.Width <- 800.0
+        base.Height <- 600.0
+        base.MinWidth <- 600.0
+        base.MinHeight <- 400.0
+        base.Content <- Main.view ()
+
+type App() =
+    inherit Application()
+
+    override this.Initialize() =
+        this.Styles.Add(FluentTheme())
+        this.Styles.Load "avares://Avalonia.Controls.ColorPicker/Themes/Fluent/Fluent.xaml"
+        this.RequestedThemeVariant <- Styling.ThemeVariant.Dark
+
+    override this.OnFrameworkInitializationCompleted() =
+        match this.ApplicationLifetime with
+        | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->
+            let mainWindow = MainWindow()
+            desktopLifetime.MainWindow <- mainWindow
+        | _ -> ()
+
+module Program =
+
+    [<EntryPoint>]
+    let main (args: string[]) =
+        AppBuilder.Configure<App>().UsePlatformDetect().UseSkia().StartWithClassicDesktopLifetime(args)
\ No newline at end of file

From f40ecfdec12ed48920345707d852ddd5f4626523 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Thu, 20 Nov 2025 09:39:39 +0900
Subject: [PATCH 14/18] [wip] Create ResourceDictionary Sample Project.

- Add ColorPicker DSL
- Add themeVariantScopeView
---
 .../Examples.ThemeSwitcher/DSL/ColorPicker.fs |  38 ++++
 .../Examples.ThemeSwitcher.fsproj             |   1 +
 src/Examples/Examples.ThemeSwitcher/Main.fs   | 182 +++++++++++++-----
 .../Examples.ThemeSwitcher/Program.fs         |   4 +
 4 files changed, 174 insertions(+), 51 deletions(-)

diff --git a/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
index e5ab8ca6..c80c24e8 100644
--- a/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
+++ b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
@@ -7,3 +7,41 @@ module ColorPicker =
     open Avalonia.FuncUI.DSL
 
     let create (attrs: IAttr<ColorPicker> list) : IView<ColorPicker> = ViewBuilder.Create<ColorPicker> (attrs)
+
+[<AutoOpen>]
+module ColorPickerDSL =
+    open Avalonia.FuncUI.Builder
+    open Avalonia.Controls.Templates
+    open Avalonia.Layout
+
+    type ColorPicker with
+
+        /// <summary>
+        /// Defines the `ColorPicker.Content` property.
+        /// </summary>
+        static member content<'t when 't :> ColorPicker> (value:obj)=
+            AttrBuilder<'t>.CreateProperty<obj>(ColorPicker.ContentProperty, value, ValueNone)
+
+        /// <summary>
+        /// Defines the `ColorPicker.Content` property.
+        /// </summary>
+        static member content<'t when 't :> ColorPicker> (view:IView)=
+            AttrBuilder<'t>.CreateContentSingle(ColorPicker.ContentProperty,Some view)
+
+        /// <summary>
+        /// Defines the `ColorPicker.ContentTemplate` property.
+        /// </summary>
+        static member contentTemplate<'t when 't :> ColorPicker> (value:IDataTemplate)=
+            AttrBuilder<'t>.CreateProperty<IDataTemplate>(ColorPicker.ContentTemplateProperty, value, ValueNone)
+
+        /// <summary>
+        /// Defines the `ColorPicker.HorizontalContentAlignment` property.
+        /// </summary>
+        static member horizontalContentAlignment<'t when 't :> ColorPicker> (value:HorizontalAlignment)=
+            AttrBuilder<'t>.CreateProperty<HorizontalAlignment>(ColorPicker.HorizontalContentAlignmentProperty, value, ValueNone)
+
+        /// <summary>
+        /// Defines the `ColorPicker.VerticalContentAlignment` property.
+        /// </summary>
+        static member verticalContentAlignment<'t when 't :> ColorPicker> (value:VerticalAlignment)=
+            AttrBuilder<'t>.CreateProperty<VerticalAlignment>(ColorPicker.VerticalContentAlignmentProperty, value, ValueNone)
\ No newline at end of file
diff --git a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
index 234eb2cb..39e8085d 100644
--- a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
+++ b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
@@ -21,6 +21,7 @@
         <PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Themes.Fluent" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Controls.ColorPicker" Version="$(AvaloniaVersion)" />
+        <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.1.0" />
         <ProjectReference Include="..\..\Avalonia.FuncUI\Avalonia.FuncUI.fsproj" />
     </ItemGroup>
 
diff --git a/src/Examples/Examples.ThemeSwitcher/Main.fs b/src/Examples/Examples.ThemeSwitcher/Main.fs
index baadaa71..45e09c6d 100644
--- a/src/Examples/Examples.ThemeSwitcher/Main.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Main.fs
@@ -9,28 +9,54 @@ module Main =
     open Avalonia.FuncUI.Types
     open Avalonia.Styling
     open Examples.ThemeSwitcher.DSL
+    open Avalonia.Data
 
 
     module ThemeVariant =
         let Custom = ThemeVariant ("Custom", ThemeVariant.Dark)
 
+    type ColorSet =
+        { Theme: ThemeVariant
+          Primary: Color
+          Secondary: Color
+          Background: Color
+          Surface: Color
+          Text: Color
+          Accent: Color }
+
+    module ColorSet =
+        let dark =
+            { Theme = ThemeVariant.Dark
+              Primary = Colors.CornflowerBlue
+              Secondary = Colors.LightSteelBlue
+              Background = Color.Parse ("#1E1E1E")
+              Surface = Color.Parse ("#252526")
+              Text = Colors.White
+              Accent = Colors.DodgerBlue }
+
+        let light =
+            { Theme = ThemeVariant.Light
+              Primary = Colors.RoyalBlue
+              Secondary = Colors.SteelBlue
+              Background = Colors.White
+              Surface = Color.Parse ("#F3F3F3")
+              Text = Colors.Black
+              Accent = Colors.Blue }
+
+        let customInit =
+            { Theme = ThemeVariant.Custom
+              Primary = Colors.MediumPurple
+              Secondary = Colors.Plum
+              Background = Color.Parse ("#FFF8DC")
+              Surface = Color.Parse ("#FAF0E6")
+              Text = Colors.DarkSlateGray
+              Accent = Colors.MediumOrchid }
+
     /// Define Custom ThemeVariant's Colors.
-    type State =
-        { PrimaryBrushColor: Color
-          SecondaryBrushColor: Color
-          BackgroundBrushColor: Color
-          SurfaceBrushColor: Color
-          TextBrushColor: Color
-          AccentBrushColor: Color }
+    type State = { CustomColors: ColorSet }
 
     /// Initial state with default colors.
-    let init =
-        { PrimaryBrushColor = Colors.RoyalBlue
-          SecondaryBrushColor = Colors.SteelBlue
-          BackgroundBrushColor = Colors.White
-          SurfaceBrushColor = Color.Parse ("#F3F3F3")
-          TextBrushColor = Colors.Black
-          AccentBrushColor = Colors.Blue }
+    let init () = { CustomColors = ColorSet.customInit }
 
     // Create theme-specific resources
     let createThemeResources (state: State) : IView =
@@ -43,51 +69,105 @@ module Main =
             ResourceDictionary.keyValue ("ButtonPadding", Thickness (12.0, 8.0))
 
             // Theme variant-specific resources
-            ResourceDictionary.themeDictionariesKeyValue (
-                ThemeVariant.Dark,
-                ResourceDictionary.create [
-                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (Colors.CornflowerBlue))
-                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (Colors.LightSteelBlue))
-                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (Color.Parse ("#1E1E1E")))
-                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (Color.Parse ("#252526")))
-                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (Colors.White))
-                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (Colors.DodgerBlue))
-                ]
-            )
+            for colorSet in [ ColorSet.dark; ColorSet.light; state.CustomColors ] do
+                ResourceDictionary.themeDictionariesKeyValue (
+                    colorSet.Theme,
+                    ResourceDictionary.create [
+                        ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush colorSet.Primary)
+                        ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush colorSet.Secondary)
+                        ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush colorSet.Background)
+                        ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush colorSet.Surface)
+                        ResourceDictionary.keyValue ("TextBrush", SolidColorBrush colorSet.Text)
+                        ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush colorSet.Accent)
+                    ]
+                )
+        ]
 
-            ResourceDictionary.themeDictionariesKeyValue (
-                ThemeVariant.Light,
-                ResourceDictionary.create [
-                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (Colors.RoyalBlue))
-                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (Colors.SteelBlue))
-                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (Colors.White))
-                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (Color.Parse ("#F3F3F3")))
-                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (Colors.Black))
-                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (Colors.Blue))
-                ]
-            )
+    let inline (|>!) x ([<InlineIfLambda>] f) =
+        f x
+        x
 
-            ResourceDictionary.themeDictionariesKeyValue (
-                ThemeVariant.Custom,
-                ResourceDictionary.create [
-                    ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush (state.PrimaryBrushColor))
-                    ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush (state.SecondaryBrushColor))
-                    ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush (state.BackgroundBrushColor))
-                    ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush (state.SurfaceBrushColor))
-                    ResourceDictionary.keyValue ("TextBrush", SolidColorBrush (state.TextBrushColor))
-                    ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush (state.AccentBrushColor))
+    let inline addProp<'x, 'v> (acccsessor: 'x -> System.Collections.Generic.ICollection<'v>) (vs: 'v seq) (x: 'x) =
+        let collection = acccsessor x
+        Seq.iter collection.Add vs
+        x
+
+    let themeVariantScopeView (themeVariant: ThemeVariant) (attrs) =
+        ThemeVariantScope.create [
+            yield! attrs
+            ThemeVariantScope.requestedThemeVariant themeVariant
+            ThemeVariantScope.child (
+                DockPanel.create [
+                    DockPanel.init (fun dp ->
+                        dp.Styles.AddRange [
+                            Style (fun x -> x.Is<Panel> ())
+                            |> addProp _.Setters [
+                                Setter (
+                                    Panel.BackgroundProperty,
+                                    dp.GetResourceObservable("SurfaceBrush").ToBinding ()
+                                )
+                            ]
+                            Style (fun x -> x.Is<TextBlock> ())
+                            |> addProp _.Setters [
+                                Setter (
+                                    TextBlock.ForegroundProperty,
+                                    dp.GetResourceObservable("TextBrush").ToBinding ()
+                                )
+                                Setter (
+                                    TextBlock.PaddingProperty,
+                                    dp.GetResourceObservable("DefaultPadding").ToBinding ()
+                                )
+                            ]
+                            Style (fun x -> x.Is<Button> ())
+                            |> addProp _.Setters [
+                                Setter (
+                                    Button.BackgroundProperty,
+                                    dp.GetResourceObservable("PrimaryBrush").ToBinding ()
+                                )
+                                Setter (Button.ForegroundProperty, dp.GetResourceObservable("TextBrush").ToBinding ())
+                                Setter (Button.PaddingProperty, dp.GetResourceObservable("ButtonPadding").ToBinding ())
+                            ]
+                            |> addProp _.Children [
+                                Style (fun x -> x.Nesting().Class (":pointerover"))
+                                |> addProp _.Setters [
+                                    Setter (
+                                        TextBlock.BackgroundProperty,
+                                        dp.GetResourceObservable("AccentBrush").ToBinding ()
+                                    )
+                                    Setter (
+                                        TextBlock.ForegroundProperty,
+                                        dp.GetResourceObservable("TextBrush").ToBinding ()
+                                    )
+                                ]
+                            ]
+                        ])
+                    DockPanel.lastChildFill false
+                    DockPanel.children [
+                        TextBlock.create [
+                            TextBlock.text (sprintf "Current Theme: %A" themeVariant)
+                            TextBlock.margin (Thickness (0.0, 0.0, 0.0, 16.0))
+                            TextBlock.fontSize 18.0
+                        ]
+                        Button.create [ Button.content "Sample Button" ]
+                    ]
                 ]
             )
         ]
-    
-    let colorPickerView (color:Color) =
-        ColorPicker.create []
+
+    let colorPickerView (label: string) (color: Color) =
+        ColorPicker.create [ ColorPicker.color color ]
 
     let view () =
         Component (fun ctx ->
+            let state = ctx.useStateLazy init
+            ctx.attrs [ Component.resources (createThemeResources state.Current) ]
 
             Grid.create [
-                Grid.rowDefinitions "Auto,Auto"
-                Grid.columnDefinitions "*,*"
-                Grid.children [ ColorPicker.create [] ]
+                Grid.rowDefinitions "Auto,Auto,Auto"
+                Grid.columnDefinitions "*"
+                Grid.children [
+                    themeVariantScopeView ThemeVariant.Dark [ Grid.row 0; Grid.column 0 ]
+                    themeVariantScopeView ThemeVariant.Light [ Grid.row 1; Grid.column 0 ]
+                    themeVariantScopeView ThemeVariant.Custom [ Grid.row 2; Grid.column 0 ]
+                ]
             ])
diff --git a/src/Examples/Examples.ThemeSwitcher/Program.fs b/src/Examples/Examples.ThemeSwitcher/Program.fs
index e018b435..28a4c46d 100644
--- a/src/Examples/Examples.ThemeSwitcher/Program.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Program.fs
@@ -27,6 +27,10 @@ type App() =
         this.Styles.Load "avares://Avalonia.Controls.ColorPicker/Themes/Fluent/Fluent.xaml"
         this.RequestedThemeVariant <- Styling.ThemeVariant.Dark
 
+#if DEBUG
+        this.AttachDeveloperTools() |> ignore
+#endif
+
     override this.OnFrameworkInitializationCompleted() =
         match this.ApplicationLifetime with
         | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->

From 190afd5a17cbcfd9f7ab3cf0acb15f8f28bf970a Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Fri, 21 Nov 2025 08:01:37 +0900
Subject: [PATCH 15/18] [wip] Create ResourceDictionary Sample Project.

---
 .../Examples.ThemeSwitcher.fsproj             |   9 +-
 src/Examples/Examples.ThemeSwitcher/Main.fs   | 199 +++++++++++++++---
 .../Examples.ThemeSwitcher/Program.fs         |  17 +-
 3 files changed, 180 insertions(+), 45 deletions(-)

diff --git a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
index 39e8085d..883b05ac 100644
--- a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
+++ b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
@@ -8,9 +8,10 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <Content Include="Assets\Icons\icon.ico">
-            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-        </Content>
+        <AvaloniaResource Include="Assets\Icons\icon.ico" />
+    </ItemGroup>
+
+    <ItemGroup>
         <Compile Include="DSL/ColorView.fs" />
         <Compile Include="DSL/ColorPicker.fs" />
         <Compile Include="Main.fs" />
@@ -21,7 +22,7 @@
         <PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Themes.Fluent" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Controls.ColorPicker" Version="$(AvaloniaVersion)" />
-        <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.1.0" />
+        <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.1.1" />
         <ProjectReference Include="..\..\Avalonia.FuncUI\Avalonia.FuncUI.fsproj" />
     </ItemGroup>
 
diff --git a/src/Examples/Examples.ThemeSwitcher/Main.fs b/src/Examples/Examples.ThemeSwitcher/Main.fs
index 45e09c6d..6042936e 100644
--- a/src/Examples/Examples.ThemeSwitcher/Main.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Main.fs
@@ -10,6 +10,8 @@ module Main =
     open Avalonia.Styling
     open Examples.ThemeSwitcher.DSL
     open Avalonia.Data
+    open Avalonia.Layout
+    open Avalonia.Controls.Presenters
 
 
     module ThemeVariant =
@@ -65,8 +67,9 @@ module Main =
             ResourceDictionary.keyValue ("LargeFontSize", 24.0)
             ResourceDictionary.keyValue ("MediumFontSize", 16.0)
             ResourceDictionary.keyValue ("SmallFontSize", 12.0)
-            ResourceDictionary.keyValue ("DefaultPadding", Thickness (16.0))
-            ResourceDictionary.keyValue ("ButtonPadding", Thickness (12.0, 8.0))
+            ResourceDictionary.keyValue ("DefaultMargin", Thickness 8.0)
+            ResourceDictionary.keyValue ("DefaultPadding", Thickness (12.0))
+            ResourceDictionary.keyValue ("ButtonPadding", Thickness (8.0, 4.0))
 
             // Theme variant-specific resources
             for colorSet in [ ColorSet.dark; ColorSet.light; state.CustomColors ] do
@@ -92,6 +95,9 @@ module Main =
         Seq.iter collection.Add vs
         x
 
+    let inline getResourceBinding<'t when 't :> IResourceHost> (x: 't) (key: string) =
+        x.GetResourceObservable(key).ToBinding ()
+
     let themeVariantScopeView (themeVariant: ThemeVariant) (attrs) =
         ThemeVariantScope.create [
             yield! attrs
@@ -99,63 +105,165 @@ module Main =
             ThemeVariantScope.child (
                 DockPanel.create [
                     DockPanel.init (fun dp ->
+                        let getResourceBinding = getResourceBinding dp
+
                         dp.Styles.AddRange [
+                            Style (fun x -> x.Is<Layoutable> ())
+                            |> addProp _.Setters [
+                                Setter (Layoutable.MarginProperty, getResourceBinding "DefaultMargin")
+                            ]
                             Style (fun x -> x.Is<Panel> ())
                             |> addProp _.Setters [
-                                Setter (
-                                    Panel.BackgroundProperty,
-                                    dp.GetResourceObservable("SurfaceBrush").ToBinding ()
-                                )
+                                Setter (Panel.BackgroundProperty, getResourceBinding "SurfaceBrush")
                             ]
                             Style (fun x -> x.Is<TextBlock> ())
                             |> addProp _.Setters [
-                                Setter (
-                                    TextBlock.ForegroundProperty,
-                                    dp.GetResourceObservable("TextBrush").ToBinding ()
-                                )
-                                Setter (
-                                    TextBlock.PaddingProperty,
-                                    dp.GetResourceObservable("DefaultPadding").ToBinding ()
-                                )
+                                Setter (TextBlock.ForegroundProperty, getResourceBinding "TextBrush")
                             ]
                             Style (fun x -> x.Is<Button> ())
                             |> addProp _.Setters [
-                                Setter (
-                                    Button.BackgroundProperty,
-                                    dp.GetResourceObservable("PrimaryBrush").ToBinding ()
-                                )
-                                Setter (Button.ForegroundProperty, dp.GetResourceObservable("TextBrush").ToBinding ())
-                                Setter (Button.PaddingProperty, dp.GetResourceObservable("ButtonPadding").ToBinding ())
+                                Setter (Button.BackgroundProperty, getResourceBinding "PrimaryBrush")
+                                Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
+                                Setter (Button.PaddingProperty, getResourceBinding "ButtonPadding")
                             ]
                             |> addProp _.Children [
-                                Style (fun x -> x.Nesting().Class (":pointerover"))
+                                Style (fun x -> x.Nesting().Class ("secondary"))
                                 |> addProp _.Setters [
-                                    Setter (
-                                        TextBlock.BackgroundProperty,
-                                        dp.GetResourceObservable("AccentBrush").ToBinding ()
-                                    )
-                                    Setter (
-                                        TextBlock.ForegroundProperty,
-                                        dp.GetResourceObservable("TextBrush").ToBinding ()
-                                    )
+                                    Setter (Button.BackgroundProperty, getResourceBinding "SecondaryBrush")
+                                    Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
+                                ]
+                                // "^:pointerover /template/ ContentPresenter#PART_ContentPresenter"
+                                Style (fun x ->
+                                    x
+                                        .Nesting()
+                                        .Class(":pointerover")
+                                        .Template()
+                                        .OfType<ContentPresenter>()
+                                        .Name ("PART_ContentPresenter"))
+                                |> addProp _.Setters [
+                                    Setter (Button.BackgroundProperty, getResourceBinding "AccentBrush")
+                                    Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
                                 ]
                             ]
                         ])
                     DockPanel.lastChildFill false
                     DockPanel.children [
                         TextBlock.create [
+                            TextBlock.dock Dock.Top
                             TextBlock.text (sprintf "Current Theme: %A" themeVariant)
-                            TextBlock.margin (Thickness (0.0, 0.0, 0.0, 16.0))
-                            TextBlock.fontSize 18.0
+                            TextBlock.classes [ "large" ]
+                        ]
+                        TextBlock.create [ TextBlock.dock Dock.Top; TextBlock.text "This is a sample text block." ]
+                        StackPanel.create [
+                            StackPanel.dock Dock.Top
+                            StackPanel.orientation Orientation.Horizontal
+                            StackPanel.children [
+                                Button.create [ Button.content "Sample Button" ]
+                                Button.create [ Button.classes [ "secondary" ]; Button.content "Sample Button" ]
+                            ]
                         ]
-                        Button.create [ Button.content "Sample Button" ]
                     ]
                 ]
             )
         ]
 
-    let colorPickerView (label: string) (color: Color) =
-        ColorPicker.create [ ColorPicker.color color ]
+    let colorPickerView (color: Color) onColorChanged attrs =
+        ColorPicker.create [
+            yield! attrs
+            ColorPicker.color color
+            ColorPicker.onPropertyChanged (fun e ->
+                if e.Property = ColorPicker.ColorProperty then
+                    let newColor = e.GetNewValue<Color> ()
+                    onColorChanged newColor)
+        ]
+
+    let colorView (label: string) (color: Color) onColorChanged attrs =
+        StackPanel.create [
+            yield! attrs
+            StackPanel.orientation Orientation.Horizontal
+            StackPanel.children [
+                TextBlock.create [ TextBlock.width 120.0; TextBlock.text label; TextBlock.classes [ "small" ] ]
+                colorPickerView color onColorChanged []
+            ]
+        ]
+
+    let colorSetsView (state: IWritable<State>) (attrs) =
+        Component.create (
+            "colorSetsView",
+            fun ctx ->
+                let state = ctx.usePassedLazy (fun _ -> state)
+                let defaultMargin = ctx.useStateLazy (fun () -> Thickness 0.0)
+
+                ctx.attrs [
+                    Component.onResourceObservable (
+                        "DefaultMargin",
+                        function
+                        | Some (:? Thickness as v) -> defaultMargin.Set v
+                        | _ -> ()
+                    )
+                    yield! attrs
+                ]
+
+                DockPanel.create [
+                    DockPanel.lastChildFill false
+                    DockPanel.classes [ "colorsetsview" ]
+                    DockPanel.children [
+                        TextBlock.create [
+                            TextBlock.dock Dock.Top
+                            TextBlock.classes [ "large" ]
+                            TextBlock.text $"Color Sets View: {state.Current.CustomColors.Theme}"
+                        ]
+                        colorView
+                            "Primary Color"
+                            state.Current.CustomColors.Primary
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Primary = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                        colorView
+                            "Secondary Color"
+                            state.Current.CustomColors.Secondary
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Secondary = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                        colorView
+                            "Background Color"
+                            state.Current.CustomColors.Background
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Background = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                        colorView
+                            "Surface Color"
+                            state.Current.CustomColors.Surface
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Surface = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                        colorView
+                            "Text Color"
+                            state.Current.CustomColors.Text
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Text = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                        colorView
+                            "Accent Color"
+                            state.Current.CustomColors.Accent
+                            (fun newColor ->
+                                state.Set
+                                    { state.Current with
+                                        CustomColors.Accent = newColor })
+                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                    ]
+                ]
+        )
 
     let view () =
         Component (fun ctx ->
@@ -163,9 +271,30 @@ module Main =
             ctx.attrs [ Component.resources (createThemeResources state.Current) ]
 
             Grid.create [
+                Grid.init (fun grid ->
+                    let getResourceBinding = getResourceBinding grid
+
+                    grid.Styles.AddRange [
+                        Style (fun x -> x.Is<TextBlock> ())
+                        |> addProp _.Setters [
+                            Setter (TextBlock.FontSizeProperty, getResourceBinding "MediumFontSize")
+                            Setter (TextBlock.PaddingProperty, getResourceBinding "ButtonPadding")
+                        ]
+                        |> addProp _.Children [
+                            Style (fun x -> x.Nesting().Class ("large"))
+                            |> addProp _.Setters [
+                                Setter (TextBlock.FontSizeProperty, getResourceBinding "LargeFontSize")
+                            ]
+                            Style (fun x -> x.Nesting().Class ("small"))
+                            |> addProp _.Setters [
+                                Setter (TextBlock.FontSizeProperty, getResourceBinding "SmallFontSize")
+                            ]
+                        ]
+                    ])
                 Grid.rowDefinitions "Auto,Auto,Auto"
-                Grid.columnDefinitions "*"
+                Grid.columnDefinitions "*,Auto"
                 Grid.children [
+                    colorSetsView state [ Grid.row 0; Grid.column 1; Grid.rowSpan 3 ]
                     themeVariantScopeView ThemeVariant.Dark [ Grid.row 0; Grid.column 0 ]
                     themeVariantScopeView ThemeVariant.Light [ Grid.row 1; Grid.column 0 ]
                     themeVariantScopeView ThemeVariant.Custom [ Grid.row 2; Grid.column 0 ]
diff --git a/src/Examples/Examples.ThemeSwitcher/Program.fs b/src/Examples/Examples.ThemeSwitcher/Program.fs
index 28a4c46d..775157d6 100644
--- a/src/Examples/Examples.ThemeSwitcher/Program.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Program.fs
@@ -6,16 +6,21 @@ open Avalonia.Controls.ApplicationLifetimes
 open Avalonia.Themes.Fluent
 open Avalonia.FuncUI
 open Avalonia.FuncUI.Hosts
-open Avalonia.Markup.Xaml.Styling
 
 type MainWindow() =
     inherit HostWindow()
 
     do
         base.Title <- "Theme Switcher Example"
+
+        base.Icon <-
+            System.Uri "avares://Examples.ThemeSwitcher/Assets/Icons/icon.ico"
+            |> Platform.AssetLoader.Open
+            |> WindowIcon
+
         base.Width <- 800.0
-        base.Height <- 600.0
         base.MinWidth <- 600.0
+        base.Height <- 680.0
         base.MinHeight <- 400.0
         base.Content <- Main.view ()
 
@@ -23,18 +28,18 @@ type App() =
     inherit Application()
 
     override this.Initialize() =
-        this.Styles.Add(FluentTheme())
+        this.Styles.Add (FluentTheme ())
         this.Styles.Load "avares://Avalonia.Controls.ColorPicker/Themes/Fluent/Fluent.xaml"
         this.RequestedThemeVariant <- Styling.ThemeVariant.Dark
 
 #if DEBUG
-        this.AttachDeveloperTools() |> ignore
+        this.AttachDeveloperTools () |> ignore
 #endif
 
     override this.OnFrameworkInitializationCompleted() =
         match this.ApplicationLifetime with
         | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->
-            let mainWindow = MainWindow()
+            let mainWindow = MainWindow ()
             desktopLifetime.MainWindow <- mainWindow
         | _ -> ()
 
@@ -42,4 +47,4 @@ module Program =
 
     [<EntryPoint>]
     let main (args: string[]) =
-        AppBuilder.Configure<App>().UsePlatformDetect().UseSkia().StartWithClassicDesktopLifetime(args)
\ No newline at end of file
+        AppBuilder.Configure<App>().UsePlatformDetect().UseSkia().StartWithClassicDesktopLifetime (args)

From 83e2369d77516618f0a0563b2e05bf94c866c610 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Sat, 22 Nov 2025 18:18:21 +0900
Subject: [PATCH 16/18] refactor(Examples.ThemeSwitcher): Improve code quality
 and add debug features

- Refactor ColorSet to use SolidColorBrush directly
- Replace GetResourceObservable().ToBinding() with DynamicResourceExtension
- Add debugOverlaysView for renderer diagnostics (DEBUG only)
- Simplify .editorconfig and fix formatting across DSL files
- Restrict DiagnosticsSupport package to DEBUG builds only
---
 .../Examples.ThemeSwitcher/.editorconfig      |   7 -
 .../Examples.ThemeSwitcher/DSL/ColorPicker.fs |  20 +-
 .../Examples.ThemeSwitcher/DSL/ColorView.fs   |  56 +--
 .../Examples.ThemeSwitcher.fsproj             |   5 +-
 src/Examples/Examples.ThemeSwitcher/Main.fs   | 441 ++++++++++--------
 .../Examples.ThemeSwitcher/Program.fs         |   8 +-
 6 files changed, 300 insertions(+), 237 deletions(-)

diff --git a/src/Examples/Examples.ThemeSwitcher/.editorconfig b/src/Examples/Examples.ThemeSwitcher/.editorconfig
index 0b6da013..7519f081 100644
--- a/src/Examples/Examples.ThemeSwitcher/.editorconfig
+++ b/src/Examples/Examples.ThemeSwitcher/.editorconfig
@@ -1,10 +1,3 @@
-[*.fs]
-fsharp_space_before_uppercase_invocation = true
-
-# Write a comment by starting the line with a '#'
-[*.{fs,fsx,fsi}]
-fsharp_bar_before_discriminated_union_declaration = true
-
 # Apply specific settings for a targeted subfolder
 [Main.fs]
 fsharp_experimental_elmish = true
\ No newline at end of file
diff --git a/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
index c80c24e8..cbe1575c 100644
--- a/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
+++ b/src/Examples/Examples.ThemeSwitcher/DSL/ColorPicker.fs
@@ -6,7 +6,7 @@ open Avalonia.FuncUI.Types
 module ColorPicker =
     open Avalonia.FuncUI.DSL
 
-    let create (attrs: IAttr<ColorPicker> list) : IView<ColorPicker> = ViewBuilder.Create<ColorPicker> (attrs)
+    let create (attrs: IAttr<ColorPicker> list) : IView<ColorPicker> = ViewBuilder.Create<ColorPicker>(attrs)
 
 [<AutoOpen>]
 module ColorPickerDSL =
@@ -19,29 +19,31 @@ module ColorPickerDSL =
         /// <summary>
         /// Defines the `ColorPicker.Content` property.
         /// </summary>
-        static member content<'t when 't :> ColorPicker> (value:obj)=
+        static member content<'t when 't :> ColorPicker>(value: obj) =
             AttrBuilder<'t>.CreateProperty<obj>(ColorPicker.ContentProperty, value, ValueNone)
 
         /// <summary>
         /// Defines the `ColorPicker.Content` property.
         /// </summary>
-        static member content<'t when 't :> ColorPicker> (view:IView)=
-            AttrBuilder<'t>.CreateContentSingle(ColorPicker.ContentProperty,Some view)
+        static member content<'t when 't :> ColorPicker>(view: IView) =
+            AttrBuilder<'t>.CreateContentSingle(ColorPicker.ContentProperty, Some view)
 
         /// <summary>
         /// Defines the `ColorPicker.ContentTemplate` property.
         /// </summary>
-        static member contentTemplate<'t when 't :> ColorPicker> (value:IDataTemplate)=
+        static member contentTemplate<'t when 't :> ColorPicker>(value: IDataTemplate) =
             AttrBuilder<'t>.CreateProperty<IDataTemplate>(ColorPicker.ContentTemplateProperty, value, ValueNone)
 
         /// <summary>
         /// Defines the `ColorPicker.HorizontalContentAlignment` property.
         /// </summary>
-        static member horizontalContentAlignment<'t when 't :> ColorPicker> (value:HorizontalAlignment)=
-            AttrBuilder<'t>.CreateProperty<HorizontalAlignment>(ColorPicker.HorizontalContentAlignmentProperty, value, ValueNone)
+        static member horizontalContentAlignment<'t when 't :> ColorPicker>(value: HorizontalAlignment) =
+            AttrBuilder<'t>
+                .CreateProperty<HorizontalAlignment>(ColorPicker.HorizontalContentAlignmentProperty, value, ValueNone)
 
         /// <summary>
         /// Defines the `ColorPicker.VerticalContentAlignment` property.
         /// </summary>
-        static member verticalContentAlignment<'t when 't :> ColorPicker> (value:VerticalAlignment)=
-            AttrBuilder<'t>.CreateProperty<VerticalAlignment>(ColorPicker.VerticalContentAlignmentProperty, value, ValueNone)
\ No newline at end of file
+        static member verticalContentAlignment<'t when 't :> ColorPicker>(value: VerticalAlignment) =
+            AttrBuilder<'t>
+                .CreateProperty<VerticalAlignment>(ColorPicker.VerticalContentAlignmentProperty, value, ValueNone)
diff --git a/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs b/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
index f45cd1e4..ce5b9f02 100644
--- a/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
+++ b/src/Examples/Examples.ThemeSwitcher/DSL/ColorView.fs
@@ -11,93 +11,93 @@ module ColorViewDSL =
     type ColorView with
 
         static member color<'t when 't :> ColorView>(color: Color) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<Color> (ColorView.ColorProperty, color, ValueNone)
+            AttrBuilder<'t>.CreateProperty<Color>(ColorView.ColorProperty, color, ValueNone)
 
         static member colorModel<'t when 't :> ColorView>(colorModel: ColorModel) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<ColorModel> (ColorView.ColorModelProperty, colorModel, ValueNone)
+            AttrBuilder<'t>.CreateProperty<ColorModel>(ColorView.ColorModelProperty, colorModel, ValueNone)
 
         static member colorSpectrumComponents<'t when 't :> ColorView>
             (components: ColorSpectrumComponents)
             : IAttr<'t> =
             AttrBuilder<'t>
-                .CreateProperty<ColorSpectrumComponents> (
+                .CreateProperty<ColorSpectrumComponents>(
                     ColorView.ColorSpectrumComponentsProperty,
                     components,
                     ValueNone
                 )
 
         static member colorSpectrumShape<'t when 't :> ColorView>(shape: ColorSpectrumShape) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<ColorSpectrumShape> (ColorView.ColorSpectrumShapeProperty, shape, ValueNone)
+            AttrBuilder<'t>.CreateProperty<ColorSpectrumShape>(ColorView.ColorSpectrumShapeProperty, shape, ValueNone)
 
         static member hexInputAlphaPosition<'t when 't :> ColorView>(position: AlphaComponentPosition) : IAttr<'t> =
             AttrBuilder<'t>
-                .CreateProperty<AlphaComponentPosition> (ColorView.HexInputAlphaPositionProperty, position, ValueNone)
+                .CreateProperty<AlphaComponentPosition>(ColorView.HexInputAlphaPositionProperty, position, ValueNone)
 
         static member hsvColor<'t when 't :> ColorView>(hsvColor: HsvColor) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<HsvColor> (ColorView.HsvColorProperty, hsvColor, ValueNone)
+            AttrBuilder<'t>.CreateProperty<HsvColor>(ColorView.HsvColorProperty, hsvColor, ValueNone)
 
         static member isAccentColorsVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAccentColorsVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsAccentColorsVisibleProperty, value, ValueNone)
 
         static member isAlphaEnabled<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAlphaEnabledProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsAlphaEnabledProperty, value, ValueNone)
 
         static member isAlphaVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsAlphaVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsAlphaVisibleProperty, value, ValueNone)
 
         static member isColorComponentsVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorComponentsVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorComponentsVisibleProperty, value, ValueNone)
 
         static member isColorModelVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorModelVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorModelVisibleProperty, value, ValueNone)
 
         static member isColorPaletteVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorPaletteVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorPaletteVisibleProperty, value, ValueNone)
 
         static member isColorPreviewVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorPreviewVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorPreviewVisibleProperty, value, ValueNone)
 
         static member isColorSpectrumVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorSpectrumVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorSpectrumVisibleProperty, value, ValueNone)
 
         static member isColorSpectrumSliderVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsColorSpectrumSliderVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsColorSpectrumSliderVisibleProperty, value, ValueNone)
 
         static member isComponentSliderVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsComponentSliderVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsComponentSliderVisibleProperty, value, ValueNone)
 
         static member isComponentTextInputVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsComponentTextInputVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsComponentTextInputVisibleProperty, value, ValueNone)
 
         static member isHexInputVisible<'t when 't :> ColorView>(value: bool) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<bool> (ColorView.IsHexInputVisibleProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<bool>(ColorView.IsHexInputVisibleProperty, value, ValueNone)
 
         static member maxHue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxHueProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MaxHueProperty, value, ValueNone)
 
         static member maxSaturation<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxSaturationProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MaxSaturationProperty, value, ValueNone)
 
         static member maxValue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MaxValueProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MaxValueProperty, value, ValueNone)
 
         static member minHue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinHueProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MinHueProperty, value, ValueNone)
 
         static member minSaturation<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinSaturationProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MinSaturationProperty, value, ValueNone)
 
         static member minValue<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.MinValueProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.MinValueProperty, value, ValueNone)
 
         static member paletteColors<'t when 't :> ColorView>(value: seq<Color>) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<seq<Color>> (ColorView.PaletteColorsProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<seq<Color>>(ColorView.PaletteColorsProperty, value, ValueNone)
 
         static member paletteColumnCount<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.PaletteColumnCountProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.PaletteColumnCountProperty, value, ValueNone)
 
         static member palette<'t when 't :> ColorView>(value: IColorPalette) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<IColorPalette> (ColorView.PaletteProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<IColorPalette>(ColorView.PaletteProperty, value, ValueNone)
 
         static member selectedIndex<'t when 't :> ColorView>(value: int) : IAttr<'t> =
-            AttrBuilder<'t>.CreateProperty<int> (ColorView.SelectedIndexProperty, value, ValueNone)
+            AttrBuilder<'t>.CreateProperty<int>(ColorView.SelectedIndexProperty, value, ValueNone)
diff --git a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
index 883b05ac..19851c96 100644
--- a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
+++ b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
@@ -22,7 +22,10 @@
         <PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Themes.Fluent" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Controls.ColorPicker" Version="$(AvaloniaVersion)" />
-        <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.1.1" />
+        <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.1.1" >
+          <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
+          <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
+        </PackageReference>
         <ProjectReference Include="..\..\Avalonia.FuncUI\Avalonia.FuncUI.fsproj" />
     </ItemGroup>
 
diff --git a/src/Examples/Examples.ThemeSwitcher/Main.fs b/src/Examples/Examples.ThemeSwitcher/Main.fs
index 6042936e..5d3f0a48 100644
--- a/src/Examples/Examples.ThemeSwitcher/Main.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Main.fs
@@ -9,50 +9,60 @@ module Main =
     open Avalonia.FuncUI.Types
     open Avalonia.Styling
     open Examples.ThemeSwitcher.DSL
-    open Avalonia.Data
     open Avalonia.Layout
     open Avalonia.Controls.Presenters
+    open Avalonia.Markup.Xaml.MarkupExtensions
+    open Avalonia.Rendering
 
 
     module ThemeVariant =
-        let Custom = ThemeVariant ("Custom", ThemeVariant.Dark)
+        let Custom = ThemeVariant("Custom", ThemeVariant.Light)
 
     type ColorSet =
         { Theme: ThemeVariant
-          Primary: Color
-          Secondary: Color
-          Background: Color
-          Surface: Color
-          Text: Color
-          Accent: Color }
+          PrimaryBrush: SolidColorBrush
+          SecondaryBrush: SolidColorBrush
+          BackgroundBrush: SolidColorBrush
+          SurfaceBrush: SolidColorBrush
+          TextBrush: SolidColorBrush
+          AccentBrush: SolidColorBrush }
 
     module ColorSet =
         let dark =
             { Theme = ThemeVariant.Dark
-              Primary = Colors.CornflowerBlue
-              Secondary = Colors.LightSteelBlue
-              Background = Color.Parse ("#1E1E1E")
-              Surface = Color.Parse ("#252526")
-              Text = Colors.White
-              Accent = Colors.DodgerBlue }
+              PrimaryBrush = SolidColorBrush Colors.CornflowerBlue
+              SecondaryBrush = SolidColorBrush Colors.LightSteelBlue
+              BackgroundBrush = SolidColorBrush(Color.Parse("#1E1E1E"))
+              SurfaceBrush = SolidColorBrush(Color.Parse("#252526"))
+              TextBrush = SolidColorBrush Colors.White
+              AccentBrush = SolidColorBrush Colors.DodgerBlue }
 
         let light =
             { Theme = ThemeVariant.Light
-              Primary = Colors.RoyalBlue
-              Secondary = Colors.SteelBlue
-              Background = Colors.White
-              Surface = Color.Parse ("#F3F3F3")
-              Text = Colors.Black
-              Accent = Colors.Blue }
+              PrimaryBrush = SolidColorBrush Colors.RoyalBlue
+              SecondaryBrush = SolidColorBrush Colors.SteelBlue
+              BackgroundBrush = SolidColorBrush Colors.White
+              SurfaceBrush = SolidColorBrush(Color.Parse("#F3F3F3"))
+              TextBrush = SolidColorBrush Colors.Black
+              AccentBrush = SolidColorBrush Colors.Blue }
 
         let customInit =
             { Theme = ThemeVariant.Custom
-              Primary = Colors.MediumPurple
-              Secondary = Colors.Plum
-              Background = Color.Parse ("#FFF8DC")
-              Surface = Color.Parse ("#FAF0E6")
-              Text = Colors.DarkSlateGray
-              Accent = Colors.MediumOrchid }
+              PrimaryBrush = SolidColorBrush Colors.MediumPurple
+              SecondaryBrush = SolidColorBrush Colors.Plum
+              BackgroundBrush = SolidColorBrush(Color.Parse("#FFF8DC"))
+              SurfaceBrush = SolidColorBrush(Color.Parse("#FAF0E6"))
+              TextBrush = SolidColorBrush Colors.DarkSlateGray
+              AccentBrush = SolidColorBrush Colors.MediumOrchid }
+
+        let colorsEqual (a: ColorSet) (b: ColorSet) =
+            a.PrimaryBrush.Color = b.PrimaryBrush.Color
+            && a.SecondaryBrush.Color = b.SecondaryBrush.Color
+            && a.BackgroundBrush.Color = b.BackgroundBrush.Color
+            && a.SurfaceBrush.Color = b.SurfaceBrush.Color
+            && a.TextBrush.Color = b.TextBrush.Color
+            && a.AccentBrush.Color = b.AccentBrush.Color
+
 
     /// Define Custom ThemeVariant's Colors.
     type State = { CustomColors: ColorSet }
@@ -68,89 +78,78 @@ module Main =
             ResourceDictionary.keyValue ("MediumFontSize", 16.0)
             ResourceDictionary.keyValue ("SmallFontSize", 12.0)
             ResourceDictionary.keyValue ("DefaultMargin", Thickness 8.0)
-            ResourceDictionary.keyValue ("DefaultPadding", Thickness (12.0))
-            ResourceDictionary.keyValue ("ButtonPadding", Thickness (8.0, 4.0))
+            ResourceDictionary.keyValue ("DefaultPadding", Thickness(12.0))
+            ResourceDictionary.keyValue ("ButtonPadding", Thickness(8.0, 4.0))
 
             // Theme variant-specific resources
             for colorSet in [ ColorSet.dark; ColorSet.light; state.CustomColors ] do
                 ResourceDictionary.themeDictionariesKeyValue (
                     colorSet.Theme,
                     ResourceDictionary.create [
-                        ResourceDictionary.keyValue ("PrimaryBrush", SolidColorBrush colorSet.Primary)
-                        ResourceDictionary.keyValue ("SecondaryBrush", SolidColorBrush colorSet.Secondary)
-                        ResourceDictionary.keyValue ("BackgroundBrush", SolidColorBrush colorSet.Background)
-                        ResourceDictionary.keyValue ("SurfaceBrush", SolidColorBrush colorSet.Surface)
-                        ResourceDictionary.keyValue ("TextBrush", SolidColorBrush colorSet.Text)
-                        ResourceDictionary.keyValue ("AccentBrush", SolidColorBrush colorSet.Accent)
+                        ResourceDictionary.keyValue ("PrimaryBrush", colorSet.PrimaryBrush)
+                        ResourceDictionary.keyValue ("SecondaryBrush", colorSet.SecondaryBrush)
+                        ResourceDictionary.keyValue ("BackgroundBrush", colorSet.BackgroundBrush)
+                        ResourceDictionary.keyValue ("SurfaceBrush", colorSet.SurfaceBrush)
+                        ResourceDictionary.keyValue ("TextBrush", colorSet.TextBrush)
+                        ResourceDictionary.keyValue ("AccentBrush", colorSet.AccentBrush)
                     ]
                 )
         ]
 
-    let inline (|>!) x ([<InlineIfLambda>] f) =
-        f x
-        x
-
-    let inline addProp<'x, 'v> (acccsessor: 'x -> System.Collections.Generic.ICollection<'v>) (vs: 'v seq) (x: 'x) =
+    let inline addRangeProp<'x, 'v>
+        (acccsessor: 'x -> System.Collections.Generic.ICollection<'v>)
+        (vs: 'v seq)
+        (x: 'x)
+        =
         let collection = acccsessor x
         Seq.iter collection.Add vs
         x
 
-    let inline getResourceBinding<'t when 't :> IResourceHost> (x: 't) (key: string) =
-        x.GetResourceObservable(key).ToBinding ()
-
-    let themeVariantScopeView (themeVariant: ThemeVariant) (attrs) =
+    let themeVariantScopeView (themeVariant: ThemeVariant) =
         ThemeVariantScope.create [
-            yield! attrs
             ThemeVariantScope.requestedThemeVariant themeVariant
             ThemeVariantScope.child (
                 DockPanel.create [
-                    DockPanel.init (fun dp ->
-                        let getResourceBinding = getResourceBinding dp
-
-                        dp.Styles.AddRange [
-                            Style (fun x -> x.Is<Layoutable> ())
-                            |> addProp _.Setters [
-                                Setter (Layoutable.MarginProperty, getResourceBinding "DefaultMargin")
-                            ]
-                            Style (fun x -> x.Is<Panel> ())
-                            |> addProp _.Setters [
-                                Setter (Panel.BackgroundProperty, getResourceBinding "SurfaceBrush")
-                            ]
-                            Style (fun x -> x.Is<TextBlock> ())
-                            |> addProp _.Setters [
-                                Setter (TextBlock.ForegroundProperty, getResourceBinding "TextBrush")
-                            ]
-                            Style (fun x -> x.Is<Button> ())
-                            |> addProp _.Setters [
-                                Setter (Button.BackgroundProperty, getResourceBinding "PrimaryBrush")
-                                Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
-                                Setter (Button.PaddingProperty, getResourceBinding "ButtonPadding")
-                            ]
-                            |> addProp _.Children [
-                                Style (fun x -> x.Nesting().Class ("secondary"))
-                                |> addProp _.Setters [
-                                    Setter (Button.BackgroundProperty, getResourceBinding "SecondaryBrush")
-                                    Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
-                                ]
-                                // "^:pointerover /template/ ContentPresenter#PART_ContentPresenter"
-                                Style (fun x ->
-                                    x
-                                        .Nesting()
-                                        .Class(":pointerover")
-                                        .Template()
-                                        .OfType<ContentPresenter>()
-                                        .Name ("PART_ContentPresenter"))
-                                |> addProp _.Setters [
-                                    Setter (Button.BackgroundProperty, getResourceBinding "AccentBrush")
-                                    Setter (Button.ForegroundProperty, getResourceBinding "TextBrush")
-                                ]
-                            ]
-                        ])
+                    DockPanel.init
+                        _.Styles.AddRange(
+                            [ Style _.Is<Layoutable>()
+                              |> addRangeProp _.Setters [
+                                  Setter(Layoutable.MarginProperty, DynamicResourceExtension "DefaultMargin")
+                              ]
+                              Style _.Is<Panel>()
+                              |> addRangeProp _.Setters [
+                                  Setter(Panel.BackgroundProperty, DynamicResourceExtension "SurfaceBrush")
+                              ]
+                              Style _.Is<TextBlock>()
+                              |> addRangeProp _.Setters [
+                                  Setter(TextBlock.ForegroundProperty, DynamicResourceExtension "TextBrush")
+                              ]
+                              Style _.Is<Button>()
+                              |> addRangeProp _.Setters [
+                                  Setter(Button.BackgroundProperty, DynamicResourceExtension "PrimaryBrush")
+                                  Setter(Button.PaddingProperty, DynamicResourceExtension "ButtonPadding")
+                              ]
+                              |> addRangeProp _.Children [
+                                  Style _.Nesting().Class("secondary")
+                                  |> addRangeProp _.Setters [
+                                      Setter(Button.BackgroundProperty, DynamicResourceExtension "SecondaryBrush")
+                                  ]
+                                  Style // "^:pointerover /template/ ContentPresenter#PART_ContentPresenter"
+                                      _.Nesting()
+                                          .Class(":pointerover")
+                                          .Template()
+                                          .OfType<ContentPresenter>()
+                                          .Name("PART_ContentPresenter")
+                                  |> addRangeProp _.Setters [
+                                      Setter(Button.BackgroundProperty, DynamicResourceExtension "AccentBrush")
+                                  ]
+                              ] ]
+                        )
                     DockPanel.lastChildFill false
                     DockPanel.children [
                         TextBlock.create [
                             TextBlock.dock Dock.Top
-                            TextBlock.text (sprintf "Current Theme: %A" themeVariant)
+                            TextBlock.text $"ThemeVariantScope: {themeVariant}"
                             TextBlock.classes [ "large" ]
                         ]
                         TextBlock.create [ TextBlock.dock Dock.Top; TextBlock.text "This is a sample text block." ]
@@ -167,136 +166,202 @@ module Main =
             )
         ]
 
-    let colorPickerView (color: Color) onColorChanged attrs =
-        ColorPicker.create [
-            yield! attrs
-            ColorPicker.color color
-            ColorPicker.onPropertyChanged (fun e ->
-                if e.Property = ColorPicker.ColorProperty then
-                    let newColor = e.GetNewValue<Color> ()
-                    onColorChanged newColor)
-        ]
+    let (|PropertyChanged|_|) (prop: AvaloniaProperty<'value>) (e: AvaloniaPropertyChangedEventArgs) =
+        if e.Property = prop then
+            let struct (oldValue, newValue) = e.GetOldAndNewValue<'value>()
 
-    let colorView (label: string) (color: Color) onColorChanged attrs =
-        StackPanel.create [
-            yield! attrs
-            StackPanel.orientation Orientation.Horizontal
-            StackPanel.children [
-                TextBlock.create [ TextBlock.width 120.0; TextBlock.text label; TextBlock.classes [ "small" ] ]
-                colorPickerView color onColorChanged []
-            ]
-        ]
+            if oldValue <> newValue then
+                Some(oldValue, newValue)
+            else
+                None
+        else
+            None
 
-    let colorSetsView (state: IWritable<State>) (attrs) =
+    let colorSetsView (state: IWritable<State>) =
         Component.create (
             "colorSetsView",
             fun ctx ->
                 let state = ctx.usePassedLazy (fun _ -> state)
-                let defaultMargin = ctx.useStateLazy (fun () -> Thickness 0.0)
+
+                let setColorWith updateFn newValue =
+                    { state.Current with
+                        CustomColors = updateFn state.Current.CustomColors newValue }
+                    |> state.Set
+
+                let defaultMargin = ctx.useStateLazy (fun () -> Thickness 8.0)
 
                 ctx.attrs [
                     Component.onResourceObservable (
                         "DefaultMargin",
                         function
-                        | Some (:? Thickness as v) -> defaultMargin.Set v
+                        | Some(:? Thickness as v) -> defaultMargin.Set v
                         | _ -> ()
                     )
-                    yield! attrs
                 ]
 
-                DockPanel.create [
-                    DockPanel.lastChildFill false
-                    DockPanel.classes [ "colorsetsview" ]
-                    DockPanel.children [
+                let colors = state.Current.CustomColors
+
+                let colorSetViewParams =
+                    [ nameof colors.PrimaryBrush, colors.PrimaryBrush, (fun s v -> { s with PrimaryBrush = v })
+                      nameof colors.SecondaryBrush, colors.SecondaryBrush, (fun s v -> { s with SecondaryBrush = v })
+                      nameof colors.BackgroundBrush, colors.BackgroundBrush, (fun s v -> { s with BackgroundBrush = v })
+                      nameof colors.SurfaceBrush, colors.SurfaceBrush, (fun s v -> { s with SurfaceBrush = v })
+                      nameof colors.TextBrush, colors.TextBrush, (fun s v -> { s with TextBrush = v })
+                      nameof colors.AccentBrush, colors.AccentBrush, (fun s v -> { s with AccentBrush = v }) ]
+
+                let colorSetDefinitions =
+                    List.replicate colorSetViewParams.Length "Auto" |> String.concat ","
+
+                Grid.create [
+                    Grid.columnDefinitions "Auto,*"
+                    Grid.rowDefinitions $"Auto,{colorSetDefinitions},Auto"
+                    Grid.margin defaultMargin.Current
+                    Grid.children [
                         TextBlock.create [
-                            TextBlock.dock Dock.Top
+                            TextBlock.column 0
+                            TextBlock.columnSpan 2
+                            TextBlock.row 0
                             TextBlock.classes [ "large" ]
-                            TextBlock.text $"Color Sets View: {state.Current.CustomColors.Theme}"
+                            TextBlock.text $"Color Sets View: {colors.Theme}"
+                            TextBlock.margin defaultMargin.Current
                         ]
-                        colorView
-                            "Primary Color"
-                            state.Current.CustomColors.Primary
-                            (fun newColor ->
-                                state.Set
-                                    { state.Current with
-                                        CustomColors.Primary = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
-                        colorView
-                            "Secondary Color"
-                            state.Current.CustomColors.Secondary
-                            (fun newColor ->
-                                state.Set
-                                    { state.Current with
-                                        CustomColors.Secondary = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
-                        colorView
-                            "Background Color"
-                            state.Current.CustomColors.Background
-                            (fun newColor ->
-                                state.Set
-                                    { state.Current with
-                                        CustomColors.Background = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
-                        colorView
-                            "Surface Color"
-                            state.Current.CustomColors.Surface
-                            (fun newColor ->
-                                state.Set
-                                    { state.Current with
-                                        CustomColors.Surface = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
-                        colorView
-                            "Text Color"
-                            state.Current.CustomColors.Text
-                            (fun newColor ->
-                                state.Set
-                                    { state.Current with
-                                        CustomColors.Text = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
-                        colorView
-                            "Accent Color"
-                            state.Current.CustomColors.Accent
-                            (fun newColor ->
-                                state.Set
+
+                        for idx, (label, brush, updateFn) in List.indexed colorSetViewParams do
+                            TextBlock.create [
+                                TextBlock.column 0
+                                TextBlock.row (idx + 1)
+                                TextBlock.margin defaultMargin.Current
+                                TextBlock.classes [ "small" ]
+                                TextBlock.text $"{label}:"
+                            ]
+
+                            ColorPicker.create [
+                                ColorPicker.column 1
+                                ColorPicker.row (idx + 1)
+                                ColorPicker.margin defaultMargin.Current
+                                ColorPicker.horizontalAlignment HorizontalAlignment.Right
+                                ColorPicker.color brush.Color
+                                ColorPicker.onPropertyChanged (function
+                                    | PropertyChanged ColorPicker.ColorProperty (_, newColor) ->
+                                        SolidColorBrush newColor |> setColorWith updateFn
+                                    | _ -> ())
+                            ]
+
+                        Button.create [
+                            Button.column 0
+                            Button.columnSpan 2
+                            Button.row (1 + colorSetViewParams.Length)
+                            Button.margin defaultMargin.Current
+                            Button.horizontalAlignment HorizontalAlignment.Right
+                            Button.content "Reset to Default Colors"
+                            Button.onClick (fun _ ->
+                                if not (ColorSet.colorsEqual state.Current.CustomColors ColorSet.customInit) then
                                     { state.Current with
-                                        CustomColors.Accent = newColor })
-                            [ DockPanel.dock Dock.Top; StackPanel.margin defaultMargin.Current ]
+                                        CustomColors = ColorSet.customInit }
+                                    |> state.Set)
+                        ]
+                    ]
+                ]
+        )
+
+#if DEBUG
+    let debugOverlaysView () =
+        Component.create (
+            "debugOverlaysView",
+            fun ctx ->
+                let rendererDebugOverlays = ctx.useState (RendererDebugOverlays.None, true)
+
+                let mapFlag (flag: RendererDebugOverlays) =
+                    rendererDebugOverlays
+                    |> State.map _.HasFlag(flag) (fun (flags, enabled) ->
+                        if enabled then flags ||| flag else flags &&& ~~~flag)
+
+                let showFps = mapFlag RendererDebugOverlays.Fps
+
+                let showDirtyRects = mapFlag RendererDebugOverlays.DirtyRects
+
+                let showLayoutTimeGraph = mapFlag RendererDebugOverlays.LayoutTimeGraph
+
+                let showRenderTimeGraph = mapFlag RendererDebugOverlays.RenderTimeGraph
+
+                ctx.useEffect (
+                    (fun () ->
+                        TopLevel.GetTopLevel(ctx.control).RendererDiagnostics.DebugOverlays <-
+                            rendererDebugOverlays.Current),
+                    [ EffectTrigger.AfterChange rendererDebugOverlays ]
+                )
+
+                let handleIsCheckedChanged (state: IWritable<bool>) (e: Interactivity.RoutedEventArgs) =
+                    match e.Source with
+                    | :? CheckBox as cb ->
+                        if cb.IsChecked.HasValue && state.Current <> cb.IsChecked.Value then
+                            state.Set cb.IsChecked.Value
+                    | _ -> ()
+
+                let settingViewParams =
+                    [ "Show FPS", showFps
+                      "Show Dirty Rects", showDirtyRects
+                      "Show Layout Time Graph", showLayoutTimeGraph
+                      "Show Render Time Graph", showRenderTimeGraph ]
+
+                StackPanel.create [
+                    StackPanel.orientation Orientation.Vertical
+                    StackPanel.children [
+                        for text, state in settingViewParams do
+                            CheckBox.create [
+                                CheckBox.isChecked state.Current
+                                CheckBox.onIsCheckedChanged (handleIsCheckedChanged state, OnChangeOf state.Current)
+                                CheckBox.content (TextBlock.create [ TextBlock.fontSize 8; TextBlock.text text ])
+                            ]
                     ]
                 ]
         )
+#endif
 
     let view () =
-        Component (fun ctx ->
+        Component(fun ctx ->
             let state = ctx.useStateLazy init
-            ctx.attrs [ Component.resources (createThemeResources state.Current) ]
 
             Grid.create [
-                Grid.init (fun grid ->
-                    let getResourceBinding = getResourceBinding grid
-
-                    grid.Styles.AddRange [
-                        Style (fun x -> x.Is<TextBlock> ())
-                        |> addProp _.Setters [
-                            Setter (TextBlock.FontSizeProperty, getResourceBinding "MediumFontSize")
-                            Setter (TextBlock.PaddingProperty, getResourceBinding "ButtonPadding")
-                        ]
-                        |> addProp _.Children [
-                            Style (fun x -> x.Nesting().Class ("large"))
-                            |> addProp _.Setters [
-                                Setter (TextBlock.FontSizeProperty, getResourceBinding "LargeFontSize")
-                            ]
-                            Style (fun x -> x.Nesting().Class ("small"))
-                            |> addProp _.Setters [
-                                Setter (TextBlock.FontSizeProperty, getResourceBinding "SmallFontSize")
-                            ]
-                        ]
-                    ])
+                Grid.resources (createThemeResources state.Current)
+                Grid.init
+                    _.Styles.AddRange(
+                        [ Style _.Is<TextBlock>()
+                          |> addRangeProp _.Setters [
+                              Setter(TextBlock.FontSizeProperty, DynamicResourceExtension "MediumFontSize")
+                              Setter(TextBlock.PaddingProperty, DynamicResourceExtension "ButtonPadding")
+                          ]
+                          |> addRangeProp _.Children [
+                              Style _.Nesting().Class("large")
+                              |> addRangeProp _.Setters [
+                                  Setter(TextBlock.FontSizeProperty, DynamicResourceExtension "LargeFontSize")
+                              ]
+                              Style _.Nesting().Class("small")
+                              |> addRangeProp _.Setters [
+                                  Setter(TextBlock.FontSizeProperty, DynamicResourceExtension "SmallFontSize")
+                              ]
+                          ] ]
+                    )
                 Grid.rowDefinitions "Auto,Auto,Auto"
                 Grid.columnDefinitions "*,Auto"
                 Grid.children [
-                    colorSetsView state [ Grid.row 0; Grid.column 1; Grid.rowSpan 3 ]
-                    themeVariantScopeView ThemeVariant.Dark [ Grid.row 0; Grid.column 0 ]
-                    themeVariantScopeView ThemeVariant.Light [ Grid.row 1; Grid.column 0 ]
-                    themeVariantScopeView ThemeVariant.Custom [ Grid.row 2; Grid.column 0 ]
+                    colorSetsView state
+                    |> View.withAttrs [ Grid.row 0; Grid.column 1; Grid.rowSpan 3 ]
+                    themeVariantScopeView ThemeVariant.Dark
+                    |> View.withAttrs [ Grid.row 0; Grid.column 0 ]
+                    themeVariantScopeView ThemeVariant.Light
+                    |> View.withAttrs [ Grid.row 1; Grid.column 0 ]
+                    themeVariantScopeView ThemeVariant.Custom
+                    |> View.withAttrs [ Grid.row 2; Grid.column 0 ]
+#if DEBUG
+                    debugOverlaysView ()
+                    |> View.withAttrs [
+                        Grid.row 3
+                        Grid.column 1
+                        StackPanel.margin (Thickness 8.0)
+                        StackPanel.horizontalAlignment HorizontalAlignment.Right
+                        StackPanel.verticalAlignment VerticalAlignment.Bottom
+                    ]
+#endif
                 ]
             ])
diff --git a/src/Examples/Examples.ThemeSwitcher/Program.fs b/src/Examples/Examples.ThemeSwitcher/Program.fs
index 775157d6..26d398a5 100644
--- a/src/Examples/Examples.ThemeSwitcher/Program.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Program.fs
@@ -28,18 +28,18 @@ type App() =
     inherit Application()
 
     override this.Initialize() =
-        this.Styles.Add (FluentTheme ())
+        this.Styles.Add(FluentTheme())
         this.Styles.Load "avares://Avalonia.Controls.ColorPicker/Themes/Fluent/Fluent.xaml"
         this.RequestedThemeVariant <- Styling.ThemeVariant.Dark
 
 #if DEBUG
-        this.AttachDeveloperTools () |> ignore
+        this.AttachDeveloperTools() |> ignore
 #endif
 
     override this.OnFrameworkInitializationCompleted() =
         match this.ApplicationLifetime with
         | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->
-            let mainWindow = MainWindow ()
+            let mainWindow = MainWindow()
             desktopLifetime.MainWindow <- mainWindow
         | _ -> ()
 
@@ -47,4 +47,4 @@ module Program =
 
     [<EntryPoint>]
     let main (args: string[]) =
-        AppBuilder.Configure<App>().UsePlatformDetect().UseSkia().StartWithClassicDesktopLifetime (args)
+        AppBuilder.Configure<App>().UsePlatformDetect().UseSkia().StartWithClassicDesktopLifetime(args)

From a1782cb6d9012b9d4454fa0366d3c6732574f83d Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Mon, 24 Nov 2025 14:48:59 +0900
Subject: [PATCH 17/18] feat(Examples.ThemeSwitcher): Add F12 Inspector Window
 support for component development

- Add FuncCommand helper for ICommand implementation (DEBUG only)
- Change MainWindow from HostWindow to Window with self-reference (as this)
- Add F12 key binding to open InspectorWindow
- Add Avalonia.FuncUI.Diagnostics project reference (DEBUG only)
- Prevent multiple inspector windows from opening
---
 .../Examples.ThemeSwitcher.fsproj             |  4 ++
 .../Examples.ThemeSwitcher/Program.fs         | 54 +++++++++++++++----
 2 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
index 19851c96..42660028 100644
--- a/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
+++ b/src/Examples/Examples.ThemeSwitcher/Examples.ThemeSwitcher.fsproj
@@ -27,6 +27,10 @@
           <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
         </PackageReference>
         <ProjectReference Include="..\..\Avalonia.FuncUI\Avalonia.FuncUI.fsproj" />
+        <ProjectReference Include="..\..\Avalonia.FuncUI.Diagnostics\Avalonia.FuncUI.Diagnostics.fsproj" >
+          <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
+          <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
+        </ProjectReference>
     </ItemGroup>
 
 </Project>
diff --git a/src/Examples/Examples.ThemeSwitcher/Program.fs b/src/Examples/Examples.ThemeSwitcher/Program.fs
index 26d398a5..4de8f486 100644
--- a/src/Examples/Examples.ThemeSwitcher/Program.fs
+++ b/src/Examples/Examples.ThemeSwitcher/Program.fs
@@ -1,28 +1,60 @@
 namespace Examples.ThemeSwitcher
 
+open System
 open Avalonia
 open Avalonia.Controls
 open Avalonia.Controls.ApplicationLifetimes
+open Avalonia.Input
 open Avalonia.Themes.Fluent
 open Avalonia.FuncUI
-open Avalonia.FuncUI.Hosts
+open Avalonia.FuncUI.Diagnostics
 
-type MainWindow() =
-    inherit HostWindow()
+#if DEBUG
+type FuncCommand(execute, canExecute) =
+    let canExecuteChanged = new Event<EventHandler, EventArgs>()
+
+    interface Windows.Input.ICommand with
+        [<CLIEvent>]
+        member _.CanExecuteChanged: IEvent<EventHandler, EventArgs> = canExecuteChanged.Publish
+
+        member _.CanExecute(parameter: obj) : bool = Option.ofObj parameter |> canExecute
+
+        member _.Execute(parameter: obj) : unit = Option.ofObj parameter |> execute
+#endif
+
+type MainWindow() as this =
+    inherit Window()
 
     do
-        base.Title <- "Theme Switcher Example"
+        this.Title <- "Theme Switcher Example"
 
-        base.Icon <-
-            System.Uri "avares://Examples.ThemeSwitcher/Assets/Icons/icon.ico"
+        this.Icon <-
+            Uri "avares://Examples.ThemeSwitcher/Assets/Icons/icon.ico"
             |> Platform.AssetLoader.Open
             |> WindowIcon
 
-        base.Width <- 800.0
-        base.MinWidth <- 600.0
-        base.Height <- 680.0
-        base.MinHeight <- 400.0
-        base.Content <- Main.view ()
+        this.Width <- 800.0
+        this.MinWidth <- 600.0
+        this.Height <- 680.0
+        this.MinHeight <- 400.0
+#if DEBUG
+        this.KeyBindings.AddRange
+            [ KeyBinding(
+                  // F12 key opens Inspector Window for component development
+                  Gesture = KeyGesture(Key.F12, KeyModifiers.None),
+                  Command =
+                      FuncCommand(
+                          (fun _ -> InspectorWindow(this).Show this),
+                          // Prevent multiple inspector windows
+                          (fun _ ->
+                              match Application.Current.ApplicationLifetime with
+                              | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->
+                                  desktopLifetime.Windows |> Seq.exists (fun w -> w :? InspectorWindow) |> not
+                              | _ -> false)
+                      )
+              ) ]
+#endif
+        this.Content <- Main.view ()
 
 type App() =
     inherit Application()

From 1f02ee41b3e4d124273e450846f113fbbbc52e26 Mon Sep 17 00:00:00 2001
From: SilkyFowl <16532218+SilkyFowl@users.noreply.github.com>
Date: Wed, 26 Nov 2025 08:48:17 +0900
Subject: [PATCH 18/18] update AvaloniaVersion to 11.3.9

---
 src/Directory.Build.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index afe47d4f..61173e3c 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <AvaloniaVersion>11.3.8</AvaloniaVersion>
+    <AvaloniaVersion>11.3.9</AvaloniaVersion>
     <FuncUIVersion>1.5.2</FuncUIVersion>
   </PropertyGroup>