diff --git a/src/Uno.UI/UI/Xaml/Controls/AutoSuggestBox/AutoSuggestBox.cs b/src/Uno.UI/UI/Xaml/Controls/AutoSuggestBox/AutoSuggestBox.cs
index 729ec22ac26a..a425ea012e9b 100644
--- a/src/Uno.UI/UI/Xaml/Controls/AutoSuggestBox/AutoSuggestBox.cs
+++ b/src/Uno.UI/UI/Xaml/Controls/AutoSuggestBox/AutoSuggestBox.cs
@@ -35,6 +35,7 @@ public partial class AutoSuggestBox : ItemsControl
 		private string _userInput;
 		private FrameworkElement _suggestionsContainer;
 		private IDisposable _textChangedDisposable;
+		private IDisposable _textBoxLoadedDisposable;
 
 		public AutoSuggestBox() : base()
 		{
@@ -52,7 +53,12 @@ protected override void OnApplyTemplate()
 			_layoutRoot = GetTemplateChild("LayoutRoot") as Grid;
 			_suggestionsList = GetTemplateChild("SuggestionsList") as ListView;
 			_suggestionsContainer = GetTemplateChild("SuggestionsContainer") as FrameworkElement;
-			_queryButton = GetTemplateChild("QueryButton") as Button;
+
+			// This is *expected* to be null on platforms with proper lifecycle.
+			// The queryButton is part of the TextBox template, which is not applied yet.
+			// On WinUI, QueryButton is never retrieved in OnTextBoxLoaded, not in OnApplyTemplate.
+			// We do in both to account for all our platforms.
+			_queryButton = _textBox?.GetTemplateChild("QueryButton") as Button;
 
 			// Uno specific: If the user enabled the legacy behavior for popup light dismiss default
 			// we force it to false explicitly to make sure the AutoSuggestBox works correctly.
@@ -72,15 +78,25 @@ protected override void OnApplyTemplate()
 			}
 #endif
 
-			UpdateQueryButton();
 			UpdateTextBox();
 			UpdateDescriptionVisibility(true);
 
 			_textChangedDisposable?.Dispose();
+			_textBoxLoadedDisposable?.Dispose();
 			if (_textBox is { })
 			{
 				_textBox.TextChanged += OnTextBoxTextChanged;
 				_textChangedDisposable = Disposable.Create(() => _textBox.TextChanged -= OnTextBoxTextChanged);
+
+				if (_textBox.IsLoaded)
+				{
+					UpdateQueryButton();
+				}
+				else
+				{
+					_textBox.Loaded += OnTextBoxLoaded;
+					_textBoxLoadedDisposable = Disposable.Create(() => _textBox.Loaded -= OnTextBoxLoaded);
+				}
 			}
 
 			Loaded += (s, e) => RegisterEvents();
@@ -103,6 +119,11 @@ private void OnTextBoxTextChanged(object sender, TextChangedEventArgs args)
 			OnTextChanged(args.IsUserModifyingText);
 		}
 
+		private void OnTextBoxLoaded(object sender, RoutedEventArgs args)
+		{
+			UpdateQueryButton();
+		}
+
 		private void OnItemsChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
 		{
 			UpdateSuggestionList();
@@ -273,6 +294,7 @@ void RegisterEvents()
 			if (_textBox != null)
 			{
 				_textBox.KeyDown += OnTextBoxKeyDown;
+				_queryButton = _textBox.GetTemplateChild<Button>("QueryButton");
 			}
 
 			if (_queryButton != null)
@@ -295,6 +317,7 @@ void RegisterEvents()
 		void UnregisterEvents()
 		{
 			_textChangedDisposable?.Dispose();
+			_textBoxLoadedDisposable?.Dispose();
 			if (_textBox != null)
 			{
 				_textBox.KeyDown -= OnTextBoxKeyDown;
@@ -344,6 +367,7 @@ private void OnIsSuggestionListOpenChanged(DependencyPropertyChangedEventArgs e)
 
 		private void UpdateQueryButton()
 		{
+			_queryButton = _textBox?.GetTemplateChild<Button>("QueryButton");
 			if (_queryButton == null)
 			{
 				return;
diff --git a/src/Uno.UI/UI/Xaml/Controls/CalendarView/CalendarViewBaseItemChrome.cs b/src/Uno.UI/UI/Xaml/Controls/CalendarView/CalendarViewBaseItemChrome.cs
index fcf5d78275fc..97784b786a68 100644
--- a/src/Uno.UI/UI/Xaml/Controls/CalendarView/CalendarViewBaseItemChrome.cs
+++ b/src/Uno.UI/UI/Xaml/Controls/CalendarView/CalendarViewBaseItemChrome.cs
@@ -87,7 +87,7 @@ private void Initialize_CalendarViewBaseItemChrome()
 			m_hasLabel = false;
 		}
 
-		private bool HasTemplateChild()
+		private protected override bool HasTemplateChild()
 		{
 			return GetFirstChildNoAddRef() != null;
 		}
diff --git a/src/Uno.UI/UI/Xaml/Controls/ContentControl/ContentControl.cs b/src/Uno.UI/UI/Xaml/Controls/ContentControl/ContentControl.cs
index 00e2cc306695..f98ad4a083a8 100644
--- a/src/Uno.UI/UI/Xaml/Controls/ContentControl/ContentControl.cs
+++ b/src/Uno.UI/UI/Xaml/Controls/ContentControl/ContentControl.cs
@@ -192,7 +192,7 @@ protected virtual void OnContentTemplateChanged(DataTemplate oldContentTemplate,
 			}
 			else if (CanCreateTemplateWithoutParent)
 			{
-				SetUpdateControlTemplate();
+				ApplyTemplate();
 			}
 		}
 
diff --git a/src/Uno.UI/UI/Xaml/Controls/Control/Control.cs b/src/Uno.UI/UI/Xaml/Controls/Control/Control.cs
index e372d096c66d..f0c5bd41a130 100644
--- a/src/Uno.UI/UI/Xaml/Controls/Control/Control.cs
+++ b/src/Uno.UI/UI/Xaml/Controls/Control/Control.cs
@@ -38,7 +38,6 @@ public partial class Control : FrameworkElement
 	{
 		private bool _suspendStateChanges;
 		private View _templatedRoot;
-		private bool _updateTemplate;
 		private bool _suppressIsEnabled;
 
 		private void InitializeControl()
@@ -88,11 +87,6 @@ private protected virtual void ChangeVisualState(bool useTransitions)
 		{
 		}
 
-		/// <summary>
-		/// Will be set to Template when it is applied
-		/// </summary>
-		private ControlTemplate _controlTemplateUsedLastUpdate;
-
 		partial void UnregisterSubView();
 		partial void RegisterSubView(View child);
 
@@ -206,36 +200,18 @@ public ControlTemplate Template
 
 		// Using a DependencyProperty as the backing store for Template.  This enables animation, styling, binding, etc...
 		public static DependencyProperty TemplateProperty { get; } =
-			DependencyProperty.Register("Template", typeof(ControlTemplate), typeof(Control), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.ValueDoesNotInheritDataContext, (s, e) => ((Control)s)?.OnTemplateChanged(e)));
+			DependencyProperty.Register("Template", typeof(ControlTemplate), typeof(Control), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.ValueDoesNotInheritDataContext | FrameworkPropertyMetadataOptions.AffectsMeasure, (s, e) => ((Control)s)?.OnTemplateChanged(e)));
 
-		private void OnTemplateChanged(DependencyPropertyChangedEventArgs e)
+		private protected virtual void OnTemplateChanged(DependencyPropertyChangedEventArgs e)
 		{
+#if !UNO_HAS_ENHANCED_LIFECYCLE
 			_updateTemplate = true;
 			SetUpdateControlTemplate();
+#endif
 		}
 
 		#endregion
 
-		/// <summary>
-		/// Defines a method that will request the update of the control's template and request layout update.
-		/// </summary>
-		/// <param name="forceUpdate">If true, forces an update even if the control has no parent.</param>
-		internal void SetUpdateControlTemplate(bool forceUpdate = false)
-		{
-			if (
-#if !UNO_HAS_ENHANCED_LIFECYCLE
-				!FeatureConfiguration.Control.UseLegacyLazyApplyTemplate ||
-#endif
-				forceUpdate ||
-				this.HasParent() ||
-				CanCreateTemplateWithoutParent
-			)
-			{
-				UpdateTemplate();
-				this.InvalidateMeasure();
-			}
-		}
-
 		/// <summary>
 		/// Represents the single child that is the result of the control template application.
 		/// </summary>
@@ -251,10 +227,12 @@ internal View TemplatedRoot
 
 				CleanupView(_templatedRoot);
 
+#if !UNO_HAS_ENHANCED_LIFECYCLE
 				UnregisterSubView();
+#endif
 
 				_templatedRoot = value;
-
+#if !UNO_HAS_ENHANCED_LIFECYCLE
 				if (value != null)
 				{
 					RegisterSubView(value);
@@ -264,9 +242,6 @@ internal View TemplatedRoot
 						RegisterContentTemplateRoot();
 
 						if (
-#if __CROSSRUNTIME__
-							!IsLoading &&
-#endif
 							!IsLoaded && FeatureConfiguration.Control.UseDeferredOnApplyTemplate)
 						{
 							// It's too soon the call the ".OnApplyTemplate" method: it should be invoked after the "Loading" event.
@@ -291,11 +266,10 @@ internal View TemplatedRoot
 						}
 					}
 				}
+#endif
 			}
 		}
 
-		private bool _applyTemplateShouldBeInvoked;
-
 #if __ANDROID__ || __IOS__ || __MACOS__ || IS_UNIT_TESTS
 		private protected override void OnPostLoading()
 		{
@@ -309,15 +283,6 @@ private protected override void OnPostLoading()
 		}
 #endif
 
-		internal void TryCallOnApplyTemplate()
-		{
-			if (_applyTemplateShouldBeInvoked)
-			{
-				_applyTemplateShouldBeInvoked = false;
-				OnApplyTemplate();
-			}
-		}
-
 		private void SubscribeToOverridenRoutedEvents()
 		{
 			// Overridden Events are registered from constructor to ensure they are
@@ -456,10 +421,11 @@ private void SubscribeToOverridenRoutedEvents()
 
 		private protected override void OnLoaded()
 		{
+#if !UNO_HAS_ENHANCED_LIFECYCLE
 			SetUpdateControlTemplate();
+#endif
 
 			base.OnLoaded();
-
 		}
 
 		protected override Size MeasureOverride(Size availableSize)
@@ -482,20 +448,19 @@ protected override Size MeasureOverride(Size availableSize)
 		protected override Size ArrangeOverride(Size finalSize)
 			=> ArrangeFirstChild(finalSize);
 
+#if UNO_HAS_ENHANCED_LIFECYCLE
 		/// <summary>
 		/// Loads the relevant control template so that its parts can be referenced.
 		/// </summary>
 		/// <returns>A value that indicates whether the visual tree was rebuilt by this call. True if the tree was rebuilt; false if the previous visual tree was retained.</returns>
 		public bool ApplyTemplate()
 		{
-			var currentTemplateRoot = _templatedRoot;
-			SetUpdateControlTemplate(forceUpdate: true);
-
-			// When .ApplyTemplate is called manually, we should not defer the call to OnApplyTemplate
-			TryCallOnApplyTemplate();
-
-			return currentTemplateRoot != _templatedRoot;
+			InvokeApplyTemplate(out var addedVisuals);
+			return addedVisuals;
 		}
+#endif
+
+		private protected override FrameworkTemplate GetTemplate() => Template;
 
 		/// <summary>
 		/// Applies default Style and implicit/explicit Style if not applied already, and materializes template.
@@ -566,42 +531,16 @@ protected override void OnVisibilityChanged(Visibility oldValue, Visibility newV
 		{
 			base.OnVisibilityChanged(oldValue, newValue);
 
+#if !UNO_HAS_ENHANCED_LIFECYCLE
 			if (oldValue == Visibility.Collapsed && newValue == Visibility.Visible)
 			{
 				SetUpdateControlTemplate();
 			}
+#endif
 
 			OnIsFocusableChanged();
 		}
 
-		private void UpdateTemplate()
-		{
-			// If TemplatedRoot is null, it must be updated even if the templates haven't changed
-			if (TemplatedRoot == null)
-			{
-				_controlTemplateUsedLastUpdate = null;
-			}
-
-			if (_updateTemplate && !object.Equals(Template, _controlTemplateUsedLastUpdate))
-			{
-				_controlTemplateUsedLastUpdate = Template;
-
-				if (Template != null)
-				{
-					TemplatedRoot = null;
-					UnregisterSubView();
-
-					TemplatedRoot = Template.LoadContentCached(this);
-				}
-				else
-				{
-					TemplatedRoot = null;
-				}
-
-				_updateTemplate = false;
-			}
-		}
-
 		partial void RegisterContentTemplateRoot();
 
 		#region Foreground Dependency Property
diff --git a/src/Uno.UI/UI/Xaml/Controls/Control/Control.nonlifecycle.cs b/src/Uno.UI/UI/Xaml/Controls/Control/Control.nonlifecycle.cs
new file mode 100644
index 000000000000..7b1b63b9c25b
--- /dev/null
+++ b/src/Uno.UI/UI/Xaml/Controls/Control/Control.nonlifecycle.cs
@@ -0,0 +1,82 @@
+#if !UNO_HAS_ENHANCED_LIFECYCLE
+namespace Microsoft.UI.Xaml.Controls;
+
+partial class Control
+{
+	private bool _updateTemplate;
+
+	/// <summary>
+	/// Will be set to Template when it is applied
+	/// </summary>
+	private ControlTemplate _controlTemplateUsedLastUpdate;
+
+	private bool _applyTemplateShouldBeInvoked;
+
+	/// <summary>
+	/// Defines a method that will request the update of the control's template and request layout update.
+	/// </summary>
+	/// <param name="forceUpdate">If true, forces an update even if the control has no parent.</param>
+	internal void SetUpdateControlTemplate(bool forceUpdate = false)
+	{
+		if (
+			!FeatureConfiguration.Control.UseLegacyLazyApplyTemplate ||
+			forceUpdate ||
+			this.HasParent() ||
+			CanCreateTemplateWithoutParent
+		)
+		{
+			UpdateTemplate();
+			this.InvalidateMeasure();
+		}
+	}
+
+	internal void TryCallOnApplyTemplate()
+	{
+		if (_applyTemplateShouldBeInvoked)
+		{
+			_applyTemplateShouldBeInvoked = false;
+			OnApplyTemplate();
+		}
+	}
+
+	/// <summary>
+	/// Loads the relevant control template so that its parts can be referenced.
+	/// </summary>
+	/// <returns>A value that indicates whether the visual tree was rebuilt by this call. True if the tree was rebuilt; false if the previous visual tree was retained.</returns>
+	public bool ApplyTemplate()
+	{
+		var currentTemplateRoot = _templatedRoot;
+		SetUpdateControlTemplate(forceUpdate: true);
+
+		// When .ApplyTemplate is called manually, we should not defer the call to OnApplyTemplate
+		TryCallOnApplyTemplate();
+
+		return currentTemplateRoot != _templatedRoot;
+	}
+
+	private void UpdateTemplate()
+	{
+		// If TemplatedRoot is null, it must be updated even if the templates haven't changed
+		if (TemplatedRoot == null)
+		{
+			_controlTemplateUsedLastUpdate = null;
+		}
+
+		if (_updateTemplate && !object.Equals(Template, _controlTemplateUsedLastUpdate))
+		{
+			_controlTemplateUsedLastUpdate = Template;
+
+			if (Template != null)
+			{
+				TemplatedRoot = Template.LoadContentCached();
+			}
+			else
+			{
+				TemplatedRoot = null;
+			}
+
+			_updateTemplate = false;
+		}
+	}
+}
+#endif
diff --git a/src/Uno.UI/UI/Xaml/Controls/ScrollViewer/ScrollViewer.cs b/src/Uno.UI/UI/Xaml/Controls/ScrollViewer/ScrollViewer.cs
index 0b439b4f4e91..bfe55b92e3f9 100644
--- a/src/Uno.UI/UI/Xaml/Controls/ScrollViewer/ScrollViewer.cs
+++ b/src/Uno.UI/UI/Xaml/Controls/ScrollViewer/ScrollViewer.cs
@@ -188,8 +188,7 @@ public ScrollBarVisibility HorizontalScrollBarVisibility
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					ScrollBarVisibility.Disabled,
-					propertyChangedCallback: OnHorizontalScrollabilityPropertyChanged,
-					options: FrameworkPropertyMetadataOptions.Inherits
+					propertyChangedCallback: OnHorizontalScrollabilityPropertyChanged
 				)
 			);
 		#endregion
@@ -214,8 +213,7 @@ public ScrollBarVisibility VerticalScrollBarVisibility
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					ScrollBarVisibility.Auto,
-					propertyChangedCallback: OnVerticalScrollabilityPropertyChanged,
-					options: FrameworkPropertyMetadataOptions.Inherits
+					propertyChangedCallback: OnVerticalScrollabilityPropertyChanged
 				)
 			);
 		#endregion
@@ -240,8 +238,7 @@ public ScrollMode HorizontalScrollMode
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					ScrollMode.Enabled,
-					propertyChangedCallback: OnHorizontalScrollabilityPropertyChanged,
-					options: FrameworkPropertyMetadataOptions.Inherits
+					propertyChangedCallback: OnHorizontalScrollabilityPropertyChanged
 				)
 			);
 		#endregion
@@ -268,8 +265,7 @@ public ScrollMode VerticalScrollMode
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					ScrollMode.Enabled,
-					propertyChangedCallback: OnVerticalScrollabilityPropertyChanged,
-					options: FrameworkPropertyMetadataOptions.Inherits
+					propertyChangedCallback: OnVerticalScrollabilityPropertyChanged
 				)
 			);
 		#endregion
@@ -303,8 +299,7 @@ public bool BringIntoViewOnFocusChange
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					true,
-					propertyChangedCallback: OnBringIntoViewOnFocusChangeChanged,
-					options: FrameworkPropertyMetadataOptions.Inherits));
+					propertyChangedCallback: OnBringIntoViewOnFocusChangeChanged));
 
 		private static void OnBringIntoViewOnFocusChangeChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args)
 		{
@@ -336,8 +331,7 @@ public ZoomMode ZoomMode
 				typeof(ScrollViewer),
 				new FrameworkPropertyMetadata(
 					ZoomMode.Disabled,
-					propertyChangedCallback: (o, e) => ((ScrollViewer)o).OnZoomModeChanged((ZoomMode)e.NewValue),
-					options: FrameworkPropertyMetadataOptions.Inherits
+					propertyChangedCallback: (o, e) => ((ScrollViewer)o).OnZoomModeChanged((ZoomMode)e.NewValue)
 				)
 			);
 
@@ -518,7 +512,7 @@ public double ViewportWidth
 				"ComputedHorizontalScrollBarVisibility",
 				typeof(Visibility),
 				typeof(ScrollViewer),
-				new FrameworkPropertyMetadata(Visibility.Collapsed)); // This has to be collapsed by default to allow deferred loading of the template
+				new FrameworkPropertyMetadata(Visibility.Visible));
 
 		public Visibility ComputedHorizontalScrollBarVisibility
 		{
@@ -533,7 +527,7 @@ public Visibility ComputedHorizontalScrollBarVisibility
 				"ComputedVerticalScrollBarVisibility",
 				typeof(Visibility),
 				typeof(ScrollViewer),
-				new FrameworkPropertyMetadata(Visibility.Collapsed)); // This has to be collapsed by default to allow deferred loading of the template
+				new FrameworkPropertyMetadata(Visibility.Visible));
 
 		public Visibility ComputedVerticalScrollBarVisibility
 		{
@@ -611,7 +605,7 @@ public double HorizontalOffset
 			);
 		#endregion
 
-		private readonly SerialDisposable _sizeChangedSubscription = new SerialDisposable();
+		//private readonly SerialDisposable _sizeChangedSubscription = new SerialDisposable();
 
 #pragma warning disable 649 // unused member for Unit tests
 		private _ScrollContentPresenter? _presenter;
@@ -676,8 +670,9 @@ public double HorizontalOffset
 		protected override Size MeasureOverride(Size availableSize)
 		{
 			ViewportMeasureSize = availableSize;
-
-			return base.MeasureOverride(availableSize);
+			var size = base.MeasureOverride(availableSize);
+			UpdateDimensionProperties();
+			return size;
 		}
 
 		protected override Size ArrangeOverride(Size finalSize)
@@ -702,7 +697,6 @@ internal override void OnLayoutUpdated()
 		{
 			base.OnLayoutUpdated();
 #endif
-			UpdateDimensionProperties();
 			UpdateZoomedContentAlignment();
 		}
 
@@ -1055,7 +1049,7 @@ protected override void OnContentChanged(object? oldValue, object? newValue)
 				ApplyScrollContentPresenterContent(newValue);
 			}
 
-			UpdateSizeChangedSubscription();
+			//UpdateSizeChangedSubscription();
 
 			_snapPointsInfo = newValue as IScrollSnapPointsInfo;
 		}
@@ -1069,23 +1063,23 @@ private void ApplyScrollContentPresenterContent(object? content)
 			}
 		}
 
-		private void UpdateSizeChangedSubscription(bool isCleanupRequired = false)
-		{
-			// TODO HERE
-			if (!isCleanupRequired
-				&& Content is IFrameworkElement element)
-			{
-				_sizeChangedSubscription.Disposable = Disposable.Create(() => element.SizeChanged -= OnElementSizeChanged);
-				element.SizeChanged += OnElementSizeChanged;
-			}
-			else
-			{
-				_sizeChangedSubscription.Disposable = null;
-			}
-
-			void OnElementSizeChanged(object sender, SizeChangedEventArgs args)
-				=> UpdateDimensionProperties();
-		}
+		//private void UpdateSizeChangedSubscription(bool isCleanupRequired = false)
+		//{
+		//	// TODO HERE
+		//	if (!isCleanupRequired
+		//		&& Content is IFrameworkElement element)
+		//	{
+		//		_sizeChangedSubscription.Disposable = Disposable.Create(() => element.SizeChanged -= OnElementSizeChanged);
+		//		element.SizeChanged += OnElementSizeChanged;
+		//	}
+		//	else
+		//	{
+		//		_sizeChangedSubscription.Disposable = null;
+		//	}
+
+		//	void OnElementSizeChanged(object sender, SizeChangedEventArgs args)
+		//		=> UpdateDimensionProperties();
+		//}
 		#endregion
 
 		#region Managed scroll bars support
diff --git a/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.crossruntime.cs b/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.crossruntime.cs
index ba09e922c4c4..0b387d22c92f 100644
--- a/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.crossruntime.cs
+++ b/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.crossruntime.cs
@@ -161,6 +161,104 @@ void MeasureCoreWithTrace(Size availableSize)
 
 		}
 
+		// WinUI overrides this in CalendarViewBaseItemChrome, ListViewBaseItemChrome, and MediaPlayerElement.
+		private protected virtual bool HasTemplateChild()
+		{
+			return GetFirstChild() is not null;
+		}
+
+		private UIElement? GetFirstChild()
+		{
+			var children = GetChildren();
+			if (children is not null && children.Count > 0)
+			{
+				return children[0];
+			}
+
+			return null;
+		}
+
+		private protected virtual void ApplyTemplate(out bool addedVisuals)
+		{
+			addedVisuals = false;
+
+			// Applying the template will not delete existing visuals. This will be done conditionally
+			// when the template is invalidated.
+			if (!HasTemplateChild())
+			{
+				var template = GetTemplate();
+				if (template is not null)
+				{
+					//SetIsUpdatingBindings(true);
+					var child = ((IFrameworkTemplateInternal)template).LoadContent(this);
+
+					// BEGIN Uno-specific
+					if (this is Control control)
+					{
+						control.TemplatedRoot = child;
+					}
+					// END Uno-specific
+
+					//SetIsUpdatingBindings(false);
+					if (child is null)
+					{
+						return;
+					}
+
+					addedVisuals = true;
+					AddChild(child);
+				}
+			}
+		}
+
+		private protected virtual FrameworkTemplate? GetTemplate()
+		{
+			return null;
+		}
+
+		internal void InvokeApplyTemplate(out bool addedVisuals)
+		{
+			ApplyTemplate(out addedVisuals);
+
+			//if (auto visualTree = VisualTree::GetForElementNoRef(pControl))
+			// {
+			//	// Create VisualState StateTriggers and perform evaulation to determine initial state,
+			//	// if we're in the visual tree (since we need it to get our qualifier context).
+			//	// If we're not in the visual tree, we'll do this when we enter it.
+			//	IFC(CVisualStateManager2::InitializeStateTriggers(this));
+			//}
+
+			//var control = this as Control;
+
+			if (addedVisuals)
+			{
+				// UNO TODO:
+				//if (control is not null)
+				{
+					// Run all of the bindings that were created and set the
+					// properties to the values from this control
+					//IFC(control.RefreshTemplateBindings(TemplateBindingsRefreshType.All));
+				}
+				// If the object has a managed peer that is a custom type, then it might have
+				// an overloaded OnApplyTemplate. Reverse P/Invoke to get that overload, if any.
+				// If there's no overload, the default Control.OnApplyTemplate will be invoked,
+				// which will just P/Invoke back to the native CControl::OnApplyTemplate.
+				OnApplyTemplate();
+			}
+
+			// UNO TODO:
+			// Update template bindings of realized element in the template.
+			// This will update if element was realized after template was applied (no visuals added, hence it would not be updated earlier)
+			// and if element was realized in OnApplyTemplate.
+			// We should not refresh all of controls template bindings, as it could potentially overwrite values set by other ways (e.g. VSM)
+			//if (control is not null &&
+			//	control.NeedsTemplateBindingRefresh())
+			//{
+			//	control.RefreshTemplateBindings(TemplateBindingsRefreshType.WithoutInitialUpdate);
+			//}
+
+		}
+
 		private void InnerMeasureCore(Size availableSize)
 		{
 			if (_traceLayoutCycle && this.Log().IsEnabled(LogLevel.Warning))
@@ -191,13 +289,11 @@ private void InnerMeasureCore(Size availableSize)
 			//if (!bInLayoutTransition)
 			{
 				// Templates should be applied here.
-				//bTemplateApplied = InvokeApplyTemplate();
+				InvokeApplyTemplate(out _);
 
 				// TODO: BEGIN Uno specific
 				if (this is Control thisAsControl)
 				{
-					thisAsControl.ApplyTemplate();
-
 					// Update bindings to ensure resources defined
 					// in visual parents get applied.
 					this.UpdateResourceBindings();
diff --git a/src/Uno.UI/UI/Xaml/UIElement.Layout.crossruntime.cs b/src/Uno.UI/UI/Xaml/UIElement.Layout.crossruntime.cs
index b45f26c83a6c..469d4337bd66 100644
--- a/src/Uno.UI/UI/Xaml/UIElement.Layout.crossruntime.cs
+++ b/src/Uno.UI/UI/Xaml/UIElement.Layout.crossruntime.cs
@@ -329,7 +329,7 @@ private void RecursivelyApplyTemplateWorkaround()
 			// find the command bar through TemplatedParent
 			if (this is Control thisAsControl)
 			{
-				thisAsControl.TryCallOnApplyTemplate();
+				thisAsControl.ApplyTemplate();
 
 				// Update bindings to ensure resources defined
 				// in visual parents get applied.
diff --git a/src/Uno.UI/UI/Xaml/UIElement.cs b/src/Uno.UI/UI/Xaml/UIElement.cs
index 047f1e2783c6..8fc1406c4fbf 100644
--- a/src/Uno.UI/UI/Xaml/UIElement.cs
+++ b/src/Uno.UI/UI/Xaml/UIElement.cs
@@ -755,7 +755,7 @@ public void UpdateLayout()
 				return;
 			}
 
-			var root = XamlRoot?.VisualTree.RootElement;
+			var root = XamlRoot?.VisualTree.RootElement ?? this.GetContext().MainVisualTree?.RootElement;
 			if (root is null)
 			{
 				return;