diff --git a/playground/EpoxyHello.Avalonia11/ViewModels/MainWindowViewModel.cs b/playground/EpoxyHello.Avalonia11/ViewModels/MainWindowViewModel.cs
index 760483ef..7cbe7188 100644
--- a/playground/EpoxyHello.Avalonia11/ViewModels/MainWindowViewModel.cs
+++ b/playground/EpoxyHello.Avalonia11/ViewModels/MainWindowViewModel.cs
@@ -35,8 +35,7 @@ namespace EpoxyHello.Avalonia11.ViewModels;
 [ViewModel]
 public sealed class MainWindowViewModel
 {
-    //public Command Ready { get; }
-    public Well ReadyWell { get; }
+    public Well<Window> MainWindowWell { get; } = Well.Factory.Create<Window>();
 
     public bool IsEnabled { get; private set; }
 
@@ -49,12 +48,13 @@ public sealed class MainWindowViewModel
     public MainWindowViewModel()
     {
         // A handler for window opened
-        //this.Ready = Command.Factory.Create(() =>
-        this.ReadyWell = Well.Factory.Create<Window>("Opened", () =>
-        {
-            this.IsEnabled = true;
-            return default;
-        });
+        this.MainWindowWell.Add(
+            Window.WindowOpenedEvent,
+            () =>
+            {
+                this.IsEnabled = true;
+                return default;
+            });
 
         // A handler for fetch button
         this.Fetch = Command.Factory.Create(async () =>
diff --git a/playground/EpoxyHello.Avalonia11/Views/MainWindow.axaml b/playground/EpoxyHello.Avalonia11/Views/MainWindow.axaml
index 6a62ff3b..52e177b9 100644
--- a/playground/EpoxyHello.Avalonia11/Views/MainWindow.axaml
+++ b/playground/EpoxyHello.Avalonia11/Views/MainWindow.axaml
@@ -27,21 +27,13 @@
         xmlns:converters="clr-namespace:EpoxyHello.Avalonia11.Views.Converters"
         mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
         x:Class="EpoxyHello.Avalonia11.Views.MainWindow"
-        Title="EpoxyHello.Avalonia11">
+        Title="EpoxyHello.Avalonia11"
+        epoxy:Fountain.Well="{Binding MainWindowWell}">
 
     <Window.DataContext>
         <viewmodels:MainWindowViewModel />
     </Window.DataContext>
 
-    <!--
-    <epoxy:EventBinder.Events>
-        <epoxy:Event EventName="Opened" Command="{Binding Ready}" />
-    </epoxy:EventBinder.Events>
-    -->
-    <epoxy:Fountain.Ducts>
-        <epoxy:Duct Well="{Binding ReadyWell}" />
-    </epoxy:Fountain.Ducts>
-
     <DockPanel>
         <Button DockPanel.Dock="Top"
                 Height="30" Foreground="White" Background="Red"
diff --git a/src/Epoxy.Core/Anchor.cs b/src/Epoxy.Core/Anchor.cs
index 375b9a18..16b979ce 100644
--- a/src/Epoxy.Core/Anchor.cs
+++ b/src/Epoxy.Core/Anchor.cs
@@ -55,14 +55,14 @@
 using Avalonia;
 using System.Reactive;
 using DependencyObject = Avalonia.IAvaloniaObject;
-using UIElement = Avalonia.Controls.IControl;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
 using Avalonia.Reactive;
 using DependencyObject = Avalonia.AvaloniaObject;
-using UIElement = Avalonia.Controls.Control;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy;
diff --git a/src/Epoxy.Core/Fountain.cs b/src/Epoxy.Core/Fountain.cs
index 44a132fe..e82e4afb 100644
--- a/src/Epoxy.Core/Fountain.cs
+++ b/src/Epoxy.Core/Fountain.cs
@@ -22,8 +22,6 @@
 using System;
 using System.Diagnostics;
 using System.ComponentModel;
-using System.Diagnostics.CodeAnalysis;
-using System.Windows.Input;
 
 #if WINDOWS_UWP || UNO
 using Windows.UI.Xaml;
@@ -35,36 +33,36 @@
 
 #if WINDOWS_WPF || OPENSILVER
 using System.Windows;
-using System.Windows.Media.Animation;
 #endif
 
 #if XAMARIN_FORMS
 using Xamarin.Forms;
 using DependencyObject = Xamarin.Forms.BindableObject;
+using UIElement = Xamarin.Forms.VisualElement;
 #endif
 
 #if MAUI
 using Microsoft.Maui.Controls;
 using DependencyObject = Microsoft.Maui.Controls.BindableObject;
+using UIElement = Microsoft.Maui.Controls.VisualElement;
 #endif
 
 #if AVALONIA
 using Avalonia;
-using Avalonia.Data;
+using Avalonia.Interactivity;
 using System.Reactive;
 using DependencyObject = Avalonia.IAvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
-using Avalonia.Data;
+using Avalonia.Interactivity;
 using Avalonia.Reactive;
 using DependencyObject = Avalonia.AvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
-using Epoxy.Internal;
-using Epoxy.Advanced;
-
 namespace Epoxy;
 
 /// <summary>
@@ -73,300 +71,94 @@ namespace Epoxy;
 /// <remarks>See Fountain guide: https://github.com/kekyo/Epoxy#fountain</remarks>
 /// <example>
 /// <code>
-/// &lt;Window xmlns:epoxy="https://github.com/kekyo/Epoxy"&gt;
+/// &lt;Window xmlns:epoxy="https://github.com/kekyo/Epoxy"
+///    epoxy:Fountain.Well={Binding WindowWell}&gt;
 ///    &lt;!-- ... --&gt;
-///    &lt;epoxy:Fountain.Ducts&gt;
-///         &lt;!-- Binding the ViewModel's Well property --&gt;
-///         &lt;epoxy:Duct Well="{Binding ReadyWell}" /&gt;
-///    &lt;/epoxy:Fountain.Ducts&gt;
 /// &lt;/Window&gt;
 /// </code>
 /// </example>
-#if AVALONIA || AVALONIA11
 public sealed class Fountain
-#else
-public static class Fountain
-#endif
 {
+    /// <summary>
+    /// The constructor.
+    /// </summary>
+    private Fountain()
+    { }
+
 #if XAMARIN_FORMS || MAUI
-    private static readonly BindablePropertyKey DuctsPropertyKey =
-        BindableProperty.CreateAttachedReadOnly(
-            "Ducts",
-            typeof(DuctsCollection),
+    public static readonly BindableProperty WellProperty =
+        BindableProperty.CreateAttached(
+            "Well",
+            typeof(Well),
             typeof(Fountain),
             null,
-            BindingMode.OneTime,
-            null,
-            null,
+            BindingMode.OneWay,
             null,
-            null,
-            d =>
+            (b, o, n) =>
             {
-                var collection = new DuctsCollection();
-                collection.Attach(d);
-                return collection;
+                if (o is Well op)
+                {
+                    op.Release((UIElement)b);
+                }
+                if (n is Well np)
+                {
+                    np.Bind((UIElement)b);
+                }
             });
-
-    /// <summary>
-    /// Declared Ducts attached property.
-    /// </summary>
-    public static readonly BindableProperty DuctsProperty =
-        DuctsPropertyKey.BindableProperty;
-
-    /// <summary>
-    /// Get DuctsCollection instance.
-    /// </summary>
-    public static DuctsCollection? GetDucts(DependencyObject d) =>
-        (DuctsCollection?)d.GetValue(DuctsProperty);
 #elif AVALONIA || AVALONIA11
-    /// <summary>
-    /// The constructor.
-    /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    private Fountain()
-    { }
-
-    /// <summary>
-    /// Declared Ducts attached property.
-    /// </summary>
-    public static readonly AttachedProperty<DuctsCollection?> DuctsProperty =
-        AvaloniaProperty.RegisterAttached<Fountain, AvaloniaObject, DuctsCollection?>(
-            "Ducts",
-            default,
-            false,
-            BindingMode.OneTime);
+    public static readonly AvaloniaProperty<Well?> WellProperty =
+        AvaloniaProperty.RegisterAttached<Fountain, UIElement, Well?>("Well");
 
     /// <summary>
     /// The type initializer.
     /// </summary>
     static Fountain() =>
-        DuctsProperty.Changed.Subscribe(
-            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<DuctsCollection?>>(e =>
-        {
-            if (!e.OldValue.Equals(e.NewValue))
+        WellProperty.Changed.Subscribe(
+            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<Well?>>(e =>
             {
-                if (e.OldValue.GetValueOrDefault() is DuctsCollection oec)
+                if (e.OldValue.GetValueOrDefault() is { } op)
                 {
-                    oec.Detach();
+                    op.Release((UIElement)e.Sender);
                 }
-                if (e.NewValue.GetValueOrDefault() is DuctsCollection nec)
+                if (e.NewValue.GetValueOrDefault() is { } np)
                 {
-                    nec.Attach(e.Sender);
+                    np.Bind((UIElement)e.Sender);
                 }
-            }
-        }));
-
-    /// <summary>
-    /// Get DuctsCollection instance.
-    /// </summary>
-    public static DuctsCollection? GetDucts(DependencyObject d)
-    {
-        var collection = d.GetValue(DuctsProperty);
-        if (collection == null)
-        {
-            // Self generated.
-            collection = new DuctsCollection();
-            d.SetValue(DuctsProperty, collection);
-        }
-        return collection;
-    }
-
-    /// <summary>
-    /// Set DuctsCollection instance.
-    /// </summary>
-    /// <remarks>It's used internal only.
-    /// It's required for Avalonia XAML compiler.</remarks>
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    public static void SetDucts(DependencyObject d, DuctsCollection? value) =>
-        d.SetValue(DuctsProperty, value ?? new DuctsCollection());
+            }));
 #else
-    /// <summary>
-    /// Declared Ducts attached property.
-    /// </summary>
-    public static readonly DependencyProperty DuctsProperty =
+    public static readonly DependencyProperty WellProperty =
         DependencyProperty.RegisterAttached(
-#if UNO || OPENSILVER
-            "Ducts",
-#else
-            "ShadowDucts",
-#endif
-            typeof(DuctsCollection),
+            "Well",
+            typeof(Well),
             typeof(Fountain),
             new PropertyMetadata(null, (d, e) =>
             {
-                if (!object.ReferenceEquals(e.OldValue, e.NewValue))
+                if (e.OldValue is Well op)
+                {
+                    op.Release((UIElement)d);
+                }
+                if (e.NewValue is Well np)
                 {
-                    if (e.OldValue is DuctsCollection oec)
-                    {
-                        oec.Detach();
-                    }
-                    if (e.NewValue is DuctsCollection nec)
-                    {
-                        nec.Attach(d);
-                    }
+                    np.Bind((UIElement)d);
                 }
             }));
-
-    /// <summary>
-    /// Get DuctsCollection instance.
-    /// </summary>
-    public static DuctsCollection? GetDucts(DependencyObject d)
-    {
-        var collection = (DuctsCollection?)d.GetValue(DuctsProperty);
-        if (collection == null)
-        {
-            // Self generated.
-            collection = new DuctsCollection();
-            d.SetValue(DuctsProperty, collection);
-        }
-        return collection;
-    }
 #endif
-}
 
-/// <summary>
-/// Duct declaration holding collection class.
-/// </summary>
-/// <remarks>It will be implicitly used on the XAML code.
-/// 
-/// See Fountain guide: https://github.com/kekyo/Epoxy#fountain</remarks>
-#if WINDOWS_UWP || UNO
-[Windows.UI.Xaml.Data.Bindable]
-#endif
-public sealed class DuctsCollection :
-    AttachableCollection<DuctsCollection, Duct>
-{
-    /// <summary>
-    /// The constructor.
-    /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    public DuctsCollection()
-    { }
-}
-
-/// <summary>
-/// Fountain's duct declaration class.
-/// </summary>
-/// <remarks>See Fountain guide: https://github.com/kekyo/Epoxy#fountain</remarks>
-/// <example>
-/// <code>
-/// &lt;Window xmlns:epoxy="https://github.com/kekyo/Epoxy"&gt;
-///    &lt;!-- ... --&gt;
-///    &lt;epoxy:Fountain.Ducts&gt;
-///         &lt;!-- Binding the ViewModel's Well property --&gt;
-///         &lt;epoxy:Duct Well="{Binding ReadyWell}" /&gt;
-///    &lt;/epoxy:Fountain.Ducts&gt;
-/// &lt;/Window&gt;
-/// </code>
-/// </example>
-#if WINDOWS_UWP || UNO
-[Windows.UI.Xaml.Data.Bindable]
-#endif
-public sealed class Duct :
-    AttachedObject<Duct>
-{
-#if XAMARIN_FORMS || MAUI
     /// <summary>
-    /// Binds Well expression bindable property declaration.
+    /// Get Pile from this Anchor.
     /// </summary>
-    public static readonly BindableProperty WellProperty =
-        BindableProperty.Create(
-            "Well",
-            typeof(Well),
-            typeof(Duct),
-            null,
-            BindingMode.Default,
-            null,
-            (d, _, nv) => ((Duct)d).OnWellPropertyChanged(nv));
-#elif AVALONIA || AVALONIA11
-    /// <summary>
-    /// Binds ICommand expression bindable property declaration.
-    /// </summary>
-    public static readonly AvaloniaProperty<Well> WellProperty =
-        AvaloniaProperty.Register<Duct, Well>("Well");
-
-    /// <summary>
-    /// The type initializer.
-    /// </summary>
-    static Duct()
-    {
-        WellProperty.Changed.Subscribe(
-            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<Well>>(e =>
-                ((Duct)e.Sender).OnWellPropertyChanged(
-                    e.NewValue.HasValue ? e.NewValue.Value : null)));
-    }
-#else
-    /// <summary>
-    /// Binds Well expression bindable property declaration.
-    /// </summary>
-    public static readonly DependencyProperty WellProperty =
-        DependencyProperty.Register(
-            "Well",
-            typeof(Well),
-            typeof(Duct),
-            new PropertyMetadata(null, (d, e) => ((Duct)d).OnWellPropertyChanged(e.NewValue)));
-#endif
-
-    /// <summary>
-    /// The constructor.
-    /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    public Duct()
-    { }
-
-    /// <summary>
-    /// Binds Well expression.
-    /// </summary>
-    public Well? Well
-    {
-        get => (Well?)this.GetValue(WellProperty);
-        set => this.SetValue(WellProperty, value);
-    }
-
-    private Well? lastWell;
-
-    private void Unbind(object? associatedObject)
-    {
-        if (associatedObject is DependencyObject d &&
-            this.lastWell is { } lastWell)
-        {
-            this.lastWell = null;
-            lastWell.Release(d);
-        }
-    }
-
-    private void Bind(object? associatedObject, object? newWell)
-    {
-        Debug.Assert(this.lastWell == null);
-
-        if (associatedObject is DependencyObject ao &&
-            newWell is Well w)
-        {
-            w.Bind(ao);
-            this.lastWell = w;
-        }
-    }
-
-    private void OnWellPropertyChanged(object? newWell)
-    {
-        this.Unbind(this.AssociatedObject);
-        this.Bind(this.AssociatedObject, newWell);
-    }
+    public static Well? GetWell(DependencyObject d) =>
+        (Well?)d.GetValue(WellProperty);
 
     /// <summary>
-    /// Attach a parent element.
+    /// Set Pile from this Anchor.
     /// </summary>
-    protected override void OnAttached()
-    {
-        this.Unbind(this.AssociatedObject);
-        this.Bind(this.AssociatedObject, this.Well);
-    }
+    public static void SetWell(DependencyObject d, Well? well) =>
+        d.SetValue(WellProperty, well);
 
     /// <summary>
-    /// Detach already attached parent element.
+    /// Clear Pile from this Anchor.
     /// </summary>
-    protected override void OnDetaching()
-    {
-        this.Unbind(this.AssociatedObject);
-    }
+    public static void ClearWell(DependencyObject d) =>
+        d.ClearValue(WellProperty);
 }
diff --git a/src/Epoxy.Core/Internal/InternalWell.cs b/src/Epoxy.Core/Internal/InternalWell.cs
index 84c5a67a..8e6a7c6d 100644
--- a/src/Epoxy.Core/Internal/InternalWell.cs
+++ b/src/Epoxy.Core/Internal/InternalWell.cs
@@ -41,22 +41,36 @@
 
 #if XAMARIN_FORMS
 using Xamarin.Forms;
+using DependencyObject = Xamarin.Forms.BindableObject;
+using UIElement = Xamarin.Forms.VisualElement;
 #endif
 
 #if MAUI
 using Microsoft.Maui.Controls;
+using DependencyObject = Microsoft.Maui.Controls.BindableObject;
+using UIElement = Microsoft.Maui.Controls.VisualElement;
 #endif
 
-#if AVALONIA || AVALONIA11
+#if AVALONIA
 using Avalonia;
+using Avalonia.Interactivity;
+using DependencyObject = Avalonia.IAvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
+#endif
+
+#if AVALONIA11
+using Avalonia;
+using Avalonia.Interactivity;
+using DependencyObject = Avalonia.AvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy.Internal;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
-internal abstract class EventTrampoline<TTarget, TEventArgs>
+internal abstract class EventTrampoline<TTarget>
 {
-    private protected readonly string EventName;
+    public readonly string EventName;
 
     private protected EventTrampoline(
         string eventName) =>
@@ -71,8 +85,10 @@ internal void Release(TTarget target) =>
     protected abstract void OnRelease(TTarget target);
 }
 
+////////////////////////////////////////////////////////
+
 internal sealed class DynamicEventTrampoline<TTarget, TEventArgs> :
-    EventTrampoline<TTarget, TEventArgs>
+    EventTrampoline<TTarget>
 {
     private readonly Func<TEventArgs, ValueTask> action;
     private readonly EventInfo ei;
@@ -121,8 +137,10 @@ public override string ToString() =>
         $"DynamicEventTrampoline: {typeof(TTarget).FullName}.{this.EventName}";
 }
 
+////////////////////////////////////////////////////////
+
 internal sealed class StaticEventTrampoline<TTarget, TEventArgs> :
-    EventTrampoline<TTarget, TEventArgs>
+    EventTrampoline<TTarget>
 {
     private readonly IntPtr methodPtr;
     private readonly Action<TTarget, object, IntPtr> adder;
@@ -174,3 +192,87 @@ protected override void OnRelease(TTarget target) =>
     public override string ToString() =>
         $"StaticEventTrampoline: {typeof(TTarget).FullName}.{this.EventName}";
 }
+
+////////////////////////////////////////////////////////
+
+#if !(XAMARIN_FORMS || MAUI)
+internal static class RoutedEventExtension
+{
+    public static string GetFullName(this RoutedEvent routedEvent) =>
+#if OPENSILVER
+        $"RoutedEvent${routedEvent}";
+#else
+        $"RoutedEvent${routedEvent.OwnerType.FullName}.{routedEvent.Name}";
+#endif
+}
+
+internal sealed class RoutedEventTrampoline<TTarget, TEventArgs> :
+    EventTrampoline<TTarget>
+    where TTarget : UIElement
+    where TEventArgs : RoutedEventArgs
+{
+    private readonly RoutedEvent routedEvent;
+    private readonly Func<TEventArgs, ValueTask> action;
+
+    public RoutedEventTrampoline(
+        RoutedEvent routedEvent,
+        Func<TEventArgs, ValueTask> action) :
+        base(routedEvent.GetFullName())
+    {
+        this.routedEvent = routedEvent;
+        this.action = action;
+    }
+
+#if WINDOWS_WPF || OPENSILVER
+    private async void OnFireEvent(object sender, RoutedEventArgs e)
+#else
+    private async void OnFireEvent(object sender, TEventArgs e)
+#endif
+    {
+        if (this.action is { } action)
+        {
+            try
+            {
+#if WINDOWS_WPF || OPENSILVER
+                await action((TEventArgs)e);
+#else
+                await action(e);
+#endif
+            }
+            catch (Exception ex)
+            {
+                // HACK: Because the exception will ignore by 'async void' bottom stack,
+                //   (And will reraise delaying UnobservedException on finalizer thread.)
+                //   This captures logical task context and reraise on UI thread pumps immediately.
+                var edi = ExceptionDispatchInfo.Capture(ex);
+                InternalUIThread.ContinueOnUIThread(_ => edi.Throw());
+            }
+        }
+    }
+
+    protected override void OnBind(TTarget target) =>
+#if WINDOWS_WPF
+        target.AddHandler(this.routedEvent, new RoutedEventHandler(this.OnFireEvent));
+#elif OPENSILVER
+        target.AddHandler(this.routedEvent, new RoutedEventHandler(this.OnFireEvent), false);
+#else
+        target.AddHandler(this.routedEvent, this.OnFireEvent);
+#endif
+
+    protected override void OnRelease(TTarget target) =>
+#if WINDOWS_WPF
+        target.RemoveHandler(this.routedEvent, new RoutedEventHandler(this.OnFireEvent));
+#elif OPENSILVER
+        target.RemoveHandler(this.routedEvent, new RoutedEventHandler(this.OnFireEvent));
+#else
+        target.RemoveHandler(this.routedEvent, this.OnFireEvent);
+#endif
+
+    public override string ToString() =>
+#if OPENSILVER
+        $"RoutedEventTrampoline: {this.routedEvent}";
+#else
+        $"RoutedEventTrampoline: {this.routedEvent.OwnerType.FullName}.{this.routedEvent.Name}";
+#endif
+}
+#endif
diff --git a/src/Epoxy.Core/Pile.cs b/src/Epoxy.Core/Pile.cs
index 3356ba5f..51cbfadf 100644
--- a/src/Epoxy.Core/Pile.cs
+++ b/src/Epoxy.Core/Pile.cs
@@ -54,13 +54,13 @@
 #if AVALONIA
 using Avalonia;
 using DependencyObject = Avalonia.IAvaloniaObject;
-using UIElement = Avalonia.Controls.IControl;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
 using DependencyObject = Avalonia.AvaloniaObject;
-using UIElement = Avalonia.Controls.Control;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy;
@@ -143,22 +143,22 @@ internal Pile()
     /// <param name="element">Target anchoring element</param>
     internal override void Bind(UIElement element)
     {
-        if (!(element is TUIElement))
+        Debug.Assert(!this.element.IsAlive);
+
+        if (element is not TUIElement e)
         {
             throw new InvalidOperationException($"Couldn't bind this anchor: {element.GetType().FullName}.");
         }
-        this.element.Target = (TUIElement)element;
+
+        this.element.Target = e;
     }
 
     /// <summary>
     /// Will release an Anchor.
     /// </summary>
     /// <param name="element">Target anchoring element</param>
-    internal override void Release(UIElement element)
-    {
-        Debug.Assert(this.element.Target is TUIElement e && object.ReferenceEquals(e, element));
+    internal override void Release(UIElement element) =>
         this.element.Target = null;
-    }
 
     /// <summary>
     /// Execute with anchoring element.
diff --git a/src/Epoxy.Core/Well.cs b/src/Epoxy.Core/Well.cs
index 017b8f06..3355b6a0 100644
--- a/src/Epoxy.Core/Well.cs
+++ b/src/Epoxy.Core/Well.cs
@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
 //
 // Epoxy - An independent flexible XAML MVVM library for .NET
 // Copyright (c) Kouji Matsui (@kozy_kekyo, @kekyo@mastodon.cloud)
@@ -23,6 +23,7 @@
 
 using System;
 using System.ComponentModel;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
 
@@ -41,27 +42,33 @@
 #if XAMARIN_FORMS
 using Xamarin.Forms;
 using DependencyObject = Xamarin.Forms.BindableObject;
+using UIElement = Xamarin.Forms.VisualElement;
 #endif
 
 #if MAUI
 using Microsoft.Maui.Controls;
 using DependencyObject = Microsoft.Maui.Controls.BindableObject;
+using UIElement = Microsoft.Maui.Controls.VisualElement;
 #endif
 
 #if AVALONIA
 using Avalonia;
+using Avalonia.Interactivity;
 using DependencyObject = Avalonia.IAvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
+using Avalonia.Interactivity;
 using DependencyObject = Avalonia.AvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy;
 
 /// <summary>
-/// The Well base class is used with Fountain and Duct.
+/// The Well is used with Fountation, there will bind loosely and can transfer event signal.
 /// </summary>
 /// <remarks>You can use with generic Well&lt;T&gt; class.</remarks>
 public abstract class Well
@@ -75,14 +82,31 @@ private protected Well()
     /// <summary>
     /// Will bind a Fountain.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal abstract void Bind(DependencyObject d);
+    /// <param name="e">Target Fountain element</param>
+    internal abstract void Bind(UIElement e);
 
     /// <summary>
     /// Will release a Fountain.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal abstract void Release(DependencyObject d);
+    /// <param name="e">Target Fountain element</param>
+    internal abstract void Release(UIElement e);
+
+    internal abstract void InternalAdd<TEventArgs>(
+        string eventName,
+        Func<TEventArgs, ValueTask> action);
+
+    internal abstract void InternalRemove(
+        string eventName);
+
+#if !(XAMARIN_FORMS || MAUI)
+    internal abstract void InternalAdd<TEventArgs>(
+        RoutedEvent routedEvent,
+        Func<TEventArgs, ValueTask> action)
+        where TEventArgs : RoutedEventArgs;
+
+    internal abstract void InternalRemove(
+        RoutedEvent routedEvent);
+#endif
 
     public static readonly WellFactoryInstance Factory =
         WellFactoryInstance.Instance;
@@ -100,135 +124,181 @@ private WellFactoryInstance()
 }
 
 /// <summary>
-/// The Well is used with Fountation, there will bind and can transfer .NET event signal.
+/// The Well is used with Fountation, there will bind loosely and can transfer event signal.
 /// </summary>
 /// <remarks>See Fountain guide: https://github.com/kekyo/Epoxy#fountain</remarks>
 /// <example>
 /// <code>
 /// // Declared a Well into the ViewModel.
-/// this.ReadyWell = Well.Factory.Create<Window>("Loaded", async () =&gt;
+/// this.KeyDownWell = Well.Factory.Create<Panel, KeyEventArgs>("KeyDown", async e =&gt;
 /// {
 ///     // Event received.
 /// });
 /// </code>
 /// </example>
-public sealed class Well<TDependencyObject> : Well
-    where TDependencyObject : DependencyObject
+public sealed class Well<TUIElement> : Well
+    where TUIElement : UIElement
 {
-    private readonly EventTrampoline<TDependencyObject, EventArgs> et;
+    // With one or more events hooked, the WeakReference should always hold a reference.
+    // Here, WeakReference is used to consider the state where no events are hooked at all.
+
+    private readonly Dictionary<string, EventTrampoline<TUIElement>> ets = new();
+    private readonly WeakReference element =
+        new WeakReference(null);
 
     /// <summary>
     /// The constructor.
     /// </summary>
-    /// <param name="eventName">Event name</param>
-    /// <param name="action">Action</param>
-    internal Well(
-        string eventName,
-        Func<ValueTask> action) =>
-        this.et = new DynamicEventTrampoline<TDependencyObject, EventArgs>(eventName, _ => action());
-
-    internal Well(string eventName,
-        Func<ValueTask> action,
-        Action<TDependencyObject, object, IntPtr> adder,
-        Action<TDependencyObject, object, IntPtr> remover) =>
-        this.et = new StaticEventTrampoline<TDependencyObject, EventArgs>(eventName, _ => action(), adder, remover);
+    internal Well()
+    {
+    }
 
     /// <summary>
     /// Will bind a Fountain.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal override void Bind(DependencyObject d)
+    /// <param name="element">Target Fountain element</param>
+    internal override void Bind(UIElement element)
     {
-        if (d is not TDependencyObject depo)
+        Debug.Assert(!this.element.IsAlive);
+
+        if (element is not TUIElement e)
+        {
+            throw new InvalidOperationException($"Couldn't bind this Fountain: {element.GetType().FullName}.");
+        }
+
+        this.element.Target = e;
+
+        foreach (var et in this.ets.Values)
         {
-            throw new InvalidOperationException($"Couldn't bind this Fountain: {d.GetType().FullName}.");
+            et.Bind(e);
         }
-        this.et.Bind(depo);
     }
 
     /// <summary>
     /// Will release a Fountain.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal override void Release(DependencyObject d)
+    /// <param name="element">Target Fountain element</param>
+    internal override void Release(UIElement element)
     {
-        if (d is TDependencyObject depo)
+        Debug.Assert(this.element.Target is TUIElement e && object.ReferenceEquals(element, e));
+
+        foreach (var et in this.ets.Values)
         {
-            this.et.Release(depo);
+            et.Release((TUIElement)element);
         }
+
+        this.element.Target = null;
     }
 
-    /// <summary>
-    /// Generate formatted string of this instance.
-    /// </summary>
-    /// <returns>Formatted string</returns>
-    public override string ToString() =>
-        $"Well: {this.et}";
-}
+    private void InternalAdd(
+        EventTrampoline<TUIElement> et)
+    {
+        if (this.ets.TryGetValue(et.EventName, out var oet))
+        {
+            if (this.element.Target is TUIElement e)
+            {
+                oet.Release(e);
+            }
+        }
 
-/// <summary>
-/// The Well is used with Fountation, there will bind loosely and can transfer event signal.
-/// </summary>
-/// <remarks>See Fountain guide: https://github.com/kekyo/Epoxy#fountain</remarks>
-/// <example>
-/// <code>
-/// // Declared a Well into the ViewModel.
-/// this.KeyDownWell = Well.Factory.Create<Panel, KeyEventArgs>("KeyDown", async e =&gt;
-/// {
-///     // Event received.
-/// });
-/// </code>
-/// </example>
-public sealed class Well<TDependencyObject, TEventArgs> : Well
-    where TDependencyObject : DependencyObject
-{
-    private readonly EventTrampoline<TDependencyObject, TEventArgs> et;
+        this.ets[et.EventName] = et;
+
+        if (this.element.Target is TUIElement e2)
+        {
+            et.Bind(e2);
+        }
+    }
 
     /// <summary>
-    /// The constructor.
+    /// Add a handler with dynamic event trampoline.
     /// </summary>
     /// <param name="eventName">Event name</param>
-    /// <param name="action">Action</param>
-    internal Well(
+    /// <param name="action">Action delegate</param>
+    internal override void InternalAdd<TEventArgs>(
         string eventName,
-        Func<TEventArgs, ValueTask> action) =>
-        this.et = new DynamicEventTrampoline<TDependencyObject, TEventArgs>(eventName, action);
+        Func<TEventArgs, ValueTask> action)
+    {
+        var et = new DynamicEventTrampoline<TUIElement, TEventArgs>(
+            eventName, action);
+        this.InternalAdd(et);
+    }
 
-    internal Well(string eventName,
+    /// <summary>
+    /// Add a handler with static event trampoline.
+    /// </summary>
+    /// <param name="eventName">Event name</param>
+    /// <param name="action">Action delegate</param>
+    /// <param name="adder">Handler adder</param>
+    /// <param name="remover">Handler remover</param>
+    internal void InternalAdd<TEventArgs>(
+        string eventName,
         Func<TEventArgs, ValueTask> action,
-        Action<TDependencyObject, object, IntPtr> adder,
-        Action<TDependencyObject, object, IntPtr> remover) =>
-        this.et = new StaticEventTrampoline<TDependencyObject, TEventArgs>(eventName, action, adder, remover);
+        Action<TUIElement, object, IntPtr> adder,
+        Action<TUIElement, object, IntPtr> remover)
+    {
+        var et = new StaticEventTrampoline<TUIElement, TEventArgs>(
+            eventName, action, adder, remover);
+        this.InternalAdd(et);
+    }
 
     /// <summary>
-    /// Will bind a Fountain.
+    /// Remove a handler with event name.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal override void Bind(DependencyObject d)
+    /// <param name="eventName">Event name</param>
+    internal override void InternalRemove(
+        string eventName)
     {
-        if (d is not TDependencyObject depo)
+        if (this.ets.TryGetValue(eventName, out var oet))
         {
-            throw new InvalidOperationException($"Couldn't bind this Fountain: {d.GetType().FullName}.");
+            if (this.element.Target is TUIElement e)
+            {
+                oet.Release(e);
+            }
+
+            this.ets.Remove(eventName);
         }
-        this.et.Bind(depo);
     }
 
+#if !(XAMARIN_FORMS || MAUI)
     /// <summary>
-    /// Will release a Fountain.
+    /// Add a handler indicates RoutedEvent.
     /// </summary>
-    /// <param name="d">Target Fountain element</param>
-    internal override void Release(DependencyObject d)
+    /// <param name="routedEvent">RoutedEvent</param>
+    /// <param name="action">Action delegate</param>
+    internal override void InternalAdd<TEventArgs>(
+        RoutedEvent routedEvent,
+        Func<TEventArgs, ValueTask> action)
     {
-        if (d is TDependencyObject depo)
+        var et = new RoutedEventTrampoline<TUIElement, TEventArgs>(
+            routedEvent, action);
+        this.InternalAdd(et);
+    }
+
+    /// <summary>
+    /// Remove a handler indicates RoutedEvent.
+    /// </summary>
+    /// <param name="routedEvent">RoutedEvent</param>
+    internal override void InternalRemove(
+        RoutedEvent routedEvent)
+    {
+        var eventName = routedEvent.GetFullName();
+
+        if (this.ets.TryGetValue(eventName, out var oet))
         {
-            this.et.Release(depo);
+            if (this.element.Target is TUIElement e)
+            {
+                oet.Release(e);
+            }
+
+            this.ets.Remove(eventName);
         }
     }
+#endif
 
     /// <summary>
     /// Generate formatted string of this instance.
     /// </summary>
     /// <returns>Formatted string</returns>
     public override string ToString() =>
-        $"Well: {this.et}";
+        $"Well: Ducts={this.ets.Count}";
 }
diff --git a/src/Epoxy/Pile.cs b/src/Epoxy/Pile.cs
index 2477b357..ec5efbb9 100644
--- a/src/Epoxy/Pile.cs
+++ b/src/Epoxy/Pile.cs
@@ -52,13 +52,13 @@
 #if AVALONIA
 using Avalonia;
 using DependencyObject = Avalonia.IAvaloniaObject;
-using UIElement = Avalonia.Controls.IControl;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
 using DependencyObject = Avalonia.AvaloniaObject;
-using UIElement = Avalonia.Controls.Control;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy;
diff --git a/src/Epoxy/Supplemental/PileExtension.cs b/src/Epoxy/Supplemental/PileExtension.cs
index 7f10411f..04193aeb 100644
--- a/src/Epoxy/Supplemental/PileExtension.cs
+++ b/src/Epoxy/Supplemental/PileExtension.cs
@@ -42,12 +42,8 @@
 using UIElement = Microsoft.Maui.Controls.VisualElement;
 #endif
 
-#if AVALONIA
-using UIElement = Avalonia.Controls.IControl;
-#endif
-
-#if AVALONIA11
-using UIElement = Avalonia.Controls.Control;
+#if AVALONIA || AVALONIA11
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 using Epoxy.Internal;
diff --git a/src/Epoxy/Synchronized/SyncCommandFactoryExtension.cs b/src/Epoxy/Synchronized/SyncCommandFactoryExtension.cs
index 41b618b6..e2f68e39 100644
--- a/src/Epoxy/Synchronized/SyncCommandFactoryExtension.cs
+++ b/src/Epoxy/Synchronized/SyncCommandFactoryExtension.cs
@@ -92,7 +92,7 @@ public static Command CreateSync<TParameter>(
         Func<TParameter, bool> canExecute) =>
         new SyncDelegatedCommand<TParameter>(execute, canExecute);
 
-    #region Dodge mistake choicing asynchronously overloads
+    #region Avoid mistake choicing asynchronously overloads
     [EditorBrowsable(EditorBrowsableState.Never)]
     [Obsolete("Use Create instead.", true)]
     public static Command CreateSync(
diff --git a/src/Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.cs b/src/Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.cs
index 5316b065..f92535eb 100644
--- a/src/Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.cs
+++ b/src/Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.cs
@@ -64,7 +64,7 @@ public static TResult ExecuteSync<TService, TResult>(
         Func<TService, TResult> action) =>
         InternalGlobalService.ExecuteSync(action);
 
-    #region Dodge mistake choicing asynchronously overloads
+    #region Avoid mistake choicing asynchronously overloads
     [EditorBrowsable(EditorBrowsableState.Never)]
     [Obsolete("Use ExecuteAsync instead.", true)]
     public static void ExecuteSync<TService>(
diff --git a/src/Epoxy/Synchronized/SyncPileExtension.cs b/src/Epoxy/Synchronized/SyncPileExtension.cs
index 0c9c2254..ae6c0c4b 100644
--- a/src/Epoxy/Synchronized/SyncPileExtension.cs
+++ b/src/Epoxy/Synchronized/SyncPileExtension.cs
@@ -48,11 +48,11 @@
 #endif
 
 #if AVALONIA
-using UIElement = Avalonia.Controls.IControl;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
-using UIElement = Avalonia.Controls.Control;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy.Synchronized;
@@ -97,7 +97,7 @@ public static TResult RentSync<TUIElement, TResult>(
         where TUIElement : UIElement =>
         pile.InternalRentSync(action);
 
-    #region Dodge mistake choicing asynchronously overloads
+    #region Avoid mistake choicing asynchronously overloads
     [EditorBrowsable(EditorBrowsableState.Never)]
     [Obsolete("Use RentAsync instead.", true)]
     public static void RentSync<TUIElement>(
diff --git a/src/Epoxy/Synchronized/SyncViewModelExtension.cs b/src/Epoxy/Synchronized/SyncViewModelExtension.cs
index 8289d1c6..74118b63 100644
--- a/src/Epoxy/Synchronized/SyncViewModelExtension.cs
+++ b/src/Epoxy/Synchronized/SyncViewModelExtension.cs
@@ -51,7 +51,7 @@ public static void SetValueSync<TValue>(
             value => { propertyChanged(value); return default; },
             propertyName);
 
-    #region Dodge mistake choicing asynchronously overloads
+    #region Avoid mistake choicing asynchronously overloads
     [EditorBrowsable(EditorBrowsableState.Never)]
     [Obsolete("Use SetValueAsync instead.", true)]
     public static void SetValueSync<TValue>(
diff --git a/src/Epoxy/Well.cs b/src/Epoxy/Well.cs
index d4cc053a..99e0b8d2 100644
--- a/src/Epoxy/Well.cs
+++ b/src/Epoxy/Well.cs
@@ -19,6 +19,8 @@
 
 #nullable enable
 
+using Epoxy.Internal;
+
 using System;
 using System.ComponentModel;
 using System.Diagnostics;
@@ -39,21 +41,27 @@
 #if XAMARIN_FORMS
 using Xamarin.Forms;
 using DependencyObject = Xamarin.Forms.BindableObject;
+using UIElement = Xamarin.Forms.VisualElement;
 #endif
 
 #if MAUI
 using Microsoft.Maui.Controls;
 using DependencyObject = Microsoft.Maui.Controls.BindableObject;
+using UIElement = Microsoft.Maui.Controls.VisualElement;
 #endif
 
 #if AVALONIA
 using Avalonia;
+using Avalonia.Interactivity;
 using DependencyObject = Avalonia.IAvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 #if AVALONIA11
 using Avalonia;
+using Avalonia.Interactivity;
 using DependencyObject = Avalonia.AvaloniaObject;
+using UIElement = Avalonia.Interactivity.Interactive;
 #endif
 
 namespace Epoxy;
@@ -72,56 +80,117 @@ namespace Epoxy;
 /// </code>
 /// </example>
 [DebuggerStepThrough]
-public static class WellFactoryExtension
+public static class WellExtension
 {
     /// <summary>
     /// Create a Well.
     /// </summary>
-    /// <typeparam name="TDependencyObject">Target control type</typeparam>
+    /// <typeparam name="TUIElement">Target control type</typeparam>
     /// <param name="factory">Factory instance (not used)</param>
-    /// <param name="eventName">Event name</param>
-    /// <param name="action">Action handler</param>
     /// <returns>Well instance</returns>
-    public static Well<TDependencyObject> Create<TDependencyObject>(
-        this WellFactoryInstance factory,
+    public static Well<TUIElement> Create<TUIElement>(
+        this WellFactoryInstance factory)
+        where TUIElement : UIElement =>
+        new Well<TUIElement>();
+
+    /////////////////////////////////////////////////////////////////
+
+    /// <summary>
+    /// Add a well handler.
+    /// </summary>
+    /// <typeparam name="TEventArgs">Handler receive type</typeparam>
+    /// <param name="well">Well</param>
+    /// <param name="eventName">Event name</param>
+    /// <param name="action">Action delegate</param>
+    public static void Add<TEventArgs>(
+        this Well well,
         string eventName,
-        Func<ValueTask> action)
-        where TDependencyObject : DependencyObject =>
-        new Well<TDependencyObject>(eventName, action);
+        Func<TEventArgs, ValueTask> action) =>
+        well.InternalAdd(eventName, action);
 
     /// <summary>
-    /// Create a Well.
+    /// Add a well handler.
     /// </summary>
-    /// <typeparam name="TDependencyObject">Target control type</typeparam>
-    /// <typeparam name="TEventArgs">Additional parameter type</typeparam>
-    /// <param name="factory">Factory instance (not used)</param>
+    /// <param name="well">Well</param>
     /// <param name="eventName">Event name</param>
-    /// <param name="action">Action handler</param>
-    /// <returns>Well instance</returns>
-    public static Well<TDependencyObject, TEventArgs> Create<TDependencyObject, TEventArgs>(
-        this WellFactoryInstance factory,
+    /// <param name="action">Action delegate</param>
+    public static void Add(
+        this Well well,
         string eventName,
+        Func<ValueTask> action) =>
+        well.InternalAdd<EventArgs>(eventName, _ => action());
+
+    /// <summary>
+    /// Remove a well handler.
+    /// </summary>
+    /// <param name="well">Well</param>
+    /// <param name="eventName">Event name</param>
+    public static void Remove(
+        this Well well,
+        string eventName) =>
+        well.InternalRemove(eventName);
+
+#if !(XAMARIN_FORMS || MAUI)
+    /// <summary>
+    /// Add a well handler.
+    /// </summary>
+    /// <typeparam name="TEventArgs">Handler receive type</typeparam>
+    /// <param name="well">Well</param>
+    /// <param name="routedEvent">RoutedEvent</param>
+    /// <param name="action">Action delegate</param>
+    public static void Add<TEventArgs>(
+        this Well well,
+#if AVALONIA || AVALONIA11
+        RoutedEvent<TEventArgs> routedEvent,
+#else
+        RoutedEvent routedEvent,
+#endif
         Func<TEventArgs, ValueTask> action)
-        where TDependencyObject : DependencyObject =>
-        new Well<TDependencyObject, TEventArgs>(eventName, action);
+        where TEventArgs : RoutedEventArgs =>
+        well.InternalAdd(routedEvent, action);
+
+    /// <summary>
+    /// Add a well handler.
+    /// </summary>
+    /// <param name="well">Well</param>
+    /// <param name="routedEvent">RoutedEvent</param>
+    /// <param name="action">Action delegate</param>
+    public static void Add(
+        this Well well,
+        RoutedEvent routedEvent,
+        Func<ValueTask> action) =>
+        well.InternalAdd<RoutedEventArgs>(routedEvent, _ => action());
+
+    /// <summary>
+    /// Remove a well handler.
+    /// </summary>
+    /// <param name="well">Well</param>
+    /// <param name="routedEvent">RoutedEvent</param>
+    public static void Remove(
+        this Well well,
+        RoutedEvent routedEvent) =>
+        well.InternalRemove(routedEvent);
+#endif
+
+    /////////////////////////////////////////////////////////////////
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public static Well<TDependencyObject> Create<TDependencyObject>(
-        this WellFactoryInstance factory,
+    public static void Add<TUIElement, TEventArgs>(
+        this Well<TUIElement> well,
         string eventName,
-        Func<ValueTask> action,
-        Action<TDependencyObject, object, IntPtr> adder,
-        Action<TDependencyObject, object, IntPtr> remover)
-        where TDependencyObject : DependencyObject =>
-        new Well<TDependencyObject>(eventName, action, adder, remover);
+        Func<TEventArgs, ValueTask> action,
+        Action<TUIElement, object, IntPtr> adder,
+        Action<TUIElement, object, IntPtr> remover)
+        where TUIElement : UIElement =>
+        well.InternalAdd(eventName, action, adder, remover);
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public static Well<TDependencyObject, TEventArgs> Create<TDependencyObject, TEventArgs>(
-        this WellFactoryInstance factory,
+    public static void Add<TUIElement>(
+        this Well<TUIElement> well,
         string eventName,
-        Func<TEventArgs, ValueTask> action,
-        Action<TDependencyObject, object, IntPtr> adder,
-        Action<TDependencyObject, object, IntPtr> remover)
-        where TDependencyObject : DependencyObject =>
-        new Well<TDependencyObject, TEventArgs>(eventName, action, adder, remover);
+        Func<ValueTask> action,
+        Action<TUIElement, object, IntPtr> adder,
+        Action<TUIElement, object, IntPtr> remover)
+        where TUIElement : UIElement =>
+        well.InternalAdd<EventArgs>(eventName, _ => action(), adder, remover);
 }
diff --git a/src/FSharp.Epoxy/Properties/Aliases.fs b/src/FSharp.Epoxy/Properties/Aliases.fs
index 8d06a8bc..e493608a 100644
--- a/src/FSharp.Epoxy/Properties/Aliases.fs
+++ b/src/FSharp.Epoxy/Properties/Aliases.fs
@@ -24,12 +24,17 @@ type private DependencyObject = Xamarin.Forms.BindableObject
 type private UIElement = Xamarin.Forms.VisualElement
 #endif
 
+#if MAUI
+type private DependencyObject = Microsoft.Maui.Controls.BindableObject
+type private UIElement = Microsoft.Maui.Controls.VisualElement
+#endif
+
 #if AVALONIA
 type private DependencyObject = Avalonia.IAvaloniaObject
-type private UIElement = Avalonia.Controls.IControl
+type private UIElement = Avalonia.Interactivity.Interactive
 #endif
 
 #if AVALONIA11
 type private DependencyObject = Avalonia.AvaloniaObject
-type private UIElement = Avalonia.Controls.Control
+type private UIElement = Avalonia.Interactivity.Interactive
 #endif
diff --git a/src/FSharp.Epoxy/Synchronized/SyncCommandFactoryExtension.fs b/src/FSharp.Epoxy/Synchronized/SyncCommandFactoryExtension.fs
index 0f656cd0..b3f351d2 100644
--- a/src/FSharp.Epoxy/Synchronized/SyncCommandFactoryExtension.fs
+++ b/src/FSharp.Epoxy/Synchronized/SyncCommandFactoryExtension.fs
@@ -76,7 +76,7 @@ module public SyncCommandFactoryExtension =
         member __.createSync (execute: 'TParameter -> unit, canExecute: 'TParameter -> bool) =
             new SyncDelegatedCommand<'TParameter>(execute |> asAction1, canExecute |> asFunc1) :> Command
 
-        // Dodge mistake choicing asynchronously overloads
+        // Avoid mistake choicing asynchronously overloads
         [<EditorBrowsable(EditorBrowsableState.Never)>]
         [<Obsolete("Use createAsync instead.", true)>]
         member __.createSync (execute: unit -> ValueTask) =
diff --git a/src/FSharp.Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.fs b/src/FSharp.Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.fs
index 4690f12e..b638b98a 100644
--- a/src/FSharp.Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.fs
+++ b/src/FSharp.Epoxy/Synchronized/SyncGlobalServiceAccessorExtension.fs
@@ -61,7 +61,7 @@ module public SyncGlobalServiceAccessorExtension =
         member __.executeSync (action: 'TService -> 'TResult) =
             InternalGlobalService.ExecuteSync(action |> asFunc1)
 
-        // Dodge mistake choicing asynchronously overloads
+        // Avoid mistake choicing asynchronously overloads
         [<EditorBrowsable(EditorBrowsableState.Never)>]
         [<Obsolete("Use executeAsync instead.", true)>]
         member __.executeSync (action: 'TService -> Async<unit>, [<Optional; DefaultParameterValue(false)>] ignoreNotPresent) =
diff --git a/src/FSharp.Epoxy/Synchronized/SyncPileExtension.fs b/src/FSharp.Epoxy/Synchronized/SyncPileExtension.fs
index e2007e53..357934d2 100644
--- a/src/FSharp.Epoxy/Synchronized/SyncPileExtension.fs
+++ b/src/FSharp.Epoxy/Synchronized/SyncPileExtension.fs
@@ -76,7 +76,7 @@ module public SyncPileExtension =
         member pile.rentSync(action: 'TUIElement -> 'TResult) =
             pile.InternalRentSync(action |> asFunc1)
 
-        // Dodge mistake choicing asynchronously overloads
+        // Avoid mistake choicing asynchronously overloads
         [<EditorBrowsable(EditorBrowsableState.Never)>]
         [<Obsolete("Use rentAsync instead.", true)>]
         member __.rentSync(action: 'TUIElement -> Async<'TResult>) =
diff --git a/src/FSharp.Epoxy/Synchronized/SyncViewModelExtension.fs b/src/FSharp.Epoxy/Synchronized/SyncViewModelExtension.fs
index 565f4a28..493b213f 100644
--- a/src/FSharp.Epoxy/Synchronized/SyncViewModelExtension.fs
+++ b/src/FSharp.Epoxy/Synchronized/SyncViewModelExtension.fs
@@ -48,7 +48,7 @@ module public SyncViewModelExtension =
         member viewModel.setValueSync (newValue, propertyChanged: 'TValue -> unit, [<Optional; CallerMemberName>] propertyName) =
             viewModel.InternalSetValueAsync<'TValue>(newValue, propertyChanged >> unitAsValueTaskUnit |> asFunc1, propertyName) |> ignore
 
-        // Dodge mistake choicing asynchronously overloads
+        // Avoid mistake choicing asynchronously overloads
         [<EditorBrowsable(EditorBrowsableState.Never)>]
         [<Obsolete("Use setValueAsync instead.", true)>]
         member viewModel.setValueSync (newValue, propertyChanged: 'TValue -> ValueTask<unit>, [<Optional; CallerMemberName>] propertyName) =
diff --git a/src/FSharp.Epoxy/Well.fs b/src/FSharp.Epoxy/Well.fs
index 537709c3..04a7a76f 100644
--- a/src/FSharp.Epoxy/Well.fs
+++ b/src/FSharp.Epoxy/Well.fs
@@ -25,19 +25,30 @@ open Epoxy.Internal
 open System
 open System.ComponentModel
 open System.Diagnostics
-open System.Threading.Tasks
-open System.Runtime.InteropServices
 
 #if WINDOWS_UWP || UNO
-open Windows.UI.Xaml
+open Windows.UI.Xaml;
 #endif
 
 #if WINUI
-open Microsoft.UI.Xaml
+open Microsoft.UI.Xaml;
 #endif
 
 #if WINDOWS_WPF || OPENSILVER
-open System.Windows
+open System.Windows;
+#endif
+
+#if XAMARIN_FORMS
+open Xamarin.Forms;
+#endif
+
+#if MAUI
+open Microsoft.Maui.Controls;
+#endif
+
+#if AVALONIA || AVALONIA11
+open Avalonia;
+open Avalonia.Interactivity;
 #endif
 
 /// <summary>
@@ -45,47 +56,118 @@ open System.Windows
 /// </summary>
 [<DebuggerStepThrough>]
 [<AutoOpen>]
-module public WellFactoryExtension =
+module public WellExtension =
 
     type public WellFactoryInstance with
 
         /// <summary>
-        /// Create an anonymous control typed Pile.
+        /// Create a Well.
         /// </summary>
-        /// <typeparam name="TDependencyObject">Target control type</typeparam>
-        /// <param name="eventName">Event name</param>
-        /// <param name="action">Action</param>
+        /// <typeparam name="TUIElement">Target control type</typeparam>
         /// <returns>Well instance</returns>
-        member _.create<'TDependencyObject when 'TDependencyObject :> DependencyObject>(
+        member _.create<'TUIElement when 'TUIElement :> UIElement>() =
+            new Well<'TUIElement>()
+                
+    /////////////////////////////////////////////////////////////////
+
+    type public Well<'TUIElement when 'TUIElement :> UIElement> with
+
+        /// <summary>
+        /// Add a well handler.
+        /// </summary>
+        /// <typeparam name="TEventArgs">Handler receive type</typeparam>
+        /// <param name="well">Well</param>
+        /// <param name="eventName">Event name</param>
+        /// <param name="action">Action delegate</param>
+        member well.add<'TEventArgs>(
             eventName: string,
-            action: unit -> Async<unit>) =
-                new Well<'TDependencyObject>(eventName, action >> asyncUnitAsValueTaskVoid)
+            action: 'TEventArgs -> Async<unit>) =
+                well.InternalAdd(
+                    eventName,
+                    action >> asyncUnitAsValueTaskVoid)
 
         /// <summary>
-        /// Create a Pile.
+        /// Add a well handler.
         /// </summary>
-        /// <typeparam name="TDependencyObject">Target control type</typeparam>
-        /// <typeparam name="TEventArgs">Additional parameter type</typeparam>
+        /// <param name="well">Well</param>
         /// <param name="eventName">Event name</param>
-        /// <param name="action">Action</param>
-        /// <returns>Well instance</returns>
-        member _.create<'TDependencyObject, 'TEventArgs when 'TDependencyObject :> DependencyObject>(
+        /// <param name="action">Action delegate</param>
+        member well.add(
             eventName: string,
+            action: unit -> Async<unit>) =
+                well.InternalAdd<EventArgs>(
+                    eventName,
+                    fun _ -> (action() |> asyncUnitAsValueTaskVoid))
+
+        /// <summary>
+        /// Remove a well handler.
+        /// </summary>
+        /// <param name="well">Well</param>
+        /// <param name="eventName">Event name</param>
+        member well.remove(
+            eventName: string) =
+                well.InternalRemove(eventName)
+
+#if !(XAMARIN_FORMS || MAUI)
+        /// <summary>
+        /// Add a well handler.
+        /// </summary>
+        /// <typeparam name="TEventArgs">Handler receive type</typeparam>
+        /// <param name="well">Well</param>
+        /// <param name="routedEvent">RoutedEvent</param>
+        /// <param name="action">Action delegate</param>
+        member well.add<'TEventArgs when 'TEventArgs :> RoutedEventArgs>(
+#if AVALONIA || AVALONIA11
+            routedEvent: RoutedEvent<'TEventArgs>,
+#else
+            routedEvent: RoutedEvent,
+#endif
             action: 'TEventArgs -> Async<unit>) =
-                new Well<'TDependencyObject, 'TEventArgs>(eventName, action >> asyncUnitAsValueTaskVoid)
+                well.InternalAdd(
+                    routedEvent,
+                    action >> asyncUnitAsValueTaskVoid)
+
+        /// <summary>
+        /// Add a well handler.
+        /// </summary>
+        /// <param name="well">Well</param>
+        /// <param name="routedEvent">RoutedEvent</param>
+        /// <param name="action">Action delegate</param>
+        member well.add(
+            routedEvent: RoutedEvent,
+            action: unit -> Async<unit>) =
+                well.InternalAdd<RoutedEventArgs>(
+                    routedEvent,
+                    fun _ -> (action() |> asyncUnitAsValueTaskVoid))
+
+        /// <summary>
+        /// Remove a well handler.
+        /// </summary>
+        /// <param name="well">Well</param>
+        /// <param name="routedEvent">RoutedEvent</param>
+        member well.remove(
+            routedEvent: RoutedEvent) =
+                well.InternalRemove(routedEvent)
+#endif
+
+        /////////////////////////////////////////////////////////////////
 
         [<EditorBrowsable(EditorBrowsableState.Never)>]
-        member _.create<'TDependencyObject when 'TDependencyObject :> DependencyObject>(
+        member well.add<'TUIElement, 'TEventArgs when 'TUIElement :> UIElement>(
             eventName: string,
-            action: unit -> Async<unit>,
-            adder: Action<'TDependencyObject, obj, IntPtr>,
-            remover: Action<'TDependencyObject, obj, IntPtr>) =
-                new Well<'TDependencyObject>(eventName, action >> asyncUnitAsValueTaskVoid, adder, remover)
+            action: 'TEventArgs -> Async<unit>,
+            adder: Action<'TUIElement, obj, IntPtr>,
+            remover: Action<'TUIElement, obj, IntPtr>) =
+                well.InternalAdd(eventName, action >> asyncUnitAsValueTaskVoid, adder, remover)
 
         [<EditorBrowsable(EditorBrowsableState.Never)>]
-        member _.create<'TDependencyObject, 'TEventArgs when 'TDependencyObject :> DependencyObject>(
+        member well.add<'TUIElement when 'TUIElement :> UIElement>(
             eventName: string,
-            action: 'TEventArgs -> Async<unit>,
-            adder: Action<'TDependencyObject, obj, IntPtr>,
-            remover: Action<'TDependencyObject, obj, IntPtr>) =
-                new Well<'TDependencyObject, 'TEventArgs>(eventName, action >> asyncUnitAsValueTaskVoid, adder, remover)
+            action: unit -> Async<unit>,
+            adder: Action<'TUIElement, obj, IntPtr>,
+            remover: Action<'TUIElement, obj, IntPtr>) =
+                well.InternalAdd<EventArgs>(
+                    eventName,
+                    (fun _ -> (action() |> asyncUnitAsValueTaskVoid)),
+                    adder,
+                    remover)