diff --git a/.gitignore b/.gitignore
index 2bbf2b4..c89115e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,13 +46,13 @@ ExportedObj/
 # Rider Generated
 .idea
 
-# Unity3D generated meta files
+# Unity3D files
 *.pidb.meta
 *.pdb.meta
 *.mdb.meta
-
-# Unity3D generated file on crash reports
 sysinfo.txt
+!Samples~/
+!**/Samples~/**
 
 # Builds
 *.apk
@@ -61,7 +61,7 @@ sysinfo.txt
 # Crashlytics generated file
 crashlytics-build.properties
 
-#OS generated
+# OS generated
 **/.DS_Store
 **/DS_Store
 **/DS_Store?*
@@ -71,11 +71,10 @@ crashlytics-build.properties
 **/ehthumbs.db
 **/Thumbs.db
 
-#Windows generated
+# Windows generated
 *Thumbs*
 *.orig
 *.orig.meta
 *.uxf
 
 
-
diff --git a/CHANGELOG.md b/CHANGELOG.md
index dde79b0..c6face8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,44 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html)
 
+## [1.0.0] - 2025-11-04
+
+**New**:
+- Added `IUiAnalytics` interface and `UiAnalytics` implementation for performance tracking
+- Added three editor windows: `UiAnalyticsWindow`, `UiServiceHierarchyWindow`
+- Added new "UI Layer Hierarchy Visualizer" section to the `UiConfigsEditor` inspector
+- Added `UiPresenterSceneGizmos` for visual debugging in Scene view
+- Added `UiPresenterEditor` custom inspector with quick open/close buttons
+- Added multi-instance support for UI presenters via `UiInstanceId` struct and instance addresses
+- Added `UiInstance` struct to encapsulate presenter metadata (type, address, presenter reference)
+- Added feature-based presenter composition architecture with `IPresenterFeature` interface
+- Added `PresenterFeatureBase` base class for composable presenter features
+- Added `AnimationDelayFeature` and `TimeDelayFeature` components for delayed UI operations
+- Added `UiToolkitPresenterFeature` for UI Toolkit integration
+- Added `DefaultUiConfigsEditor` for out-of-the-box UI configuration (no custom implementation required)
+
+**Changed**:
+- Replaced `Task.Delay` with `UniTask.Delay` throughout for better performance and WebGL compatibility
+- Updated `CloseAllUi` to avoid modifying collection during iteration
+- Enhanced `UiService.Dispose()` with proper cleanup of all presenters, layers, and asset loader
+- `LoadUiAsync`, `OpenUiAsync` methods now accept optional `CancellationToken` parameter
+- Updated the README with a complete information of the project
+- Replaced `LoadedPresenters` property with `GetLoadedPresenters()` method for better encapsulation
+- Migrated all delay functionality from `PresenterDelayerBase` to feature-based system (`AnimationDelayFeature`, `TimeDelayFeature`)
+- Converted all editor scripts to use UI Toolkit for better performance and modern UI
+- Refactored `UiConfigsEditor` to use UI Toolkit with improved visuals and drag-and-drop support
+- Optimized collection types (`Dictionary`, `List`) for better performance in `UiService`
+- Removed loading spinner from `UiService` (simplified initialization)
+
+**Fixed**:
+- **CRITICAL**: Fixed `GetOrLoadUiAsync` returning null when loading new UI (now properly assigns return value)
+- Fixed exception handling in `UnloadUi` with proper `TryGetValue` checks
+- Fixed exception handling in `RemoveUiSet` with proper `TryGetValue` checks
+- Fixed redundant operations in `CloseAllUi` logic
+- Fixed initial value handling for UI sets in editor
+- Fixed serialization updates before property binding in editor
+- Fixed script indentation issues in delay presenter implementations
+
 ## [0.13.1] - 2025-09-28
 
 **New**:
diff --git a/Editor/DefaultUiConfigsEditor.cs b/Editor/DefaultUiConfigsEditor.cs
new file mode 100644
index 0000000..4029908
--- /dev/null
+++ b/Editor/DefaultUiConfigsEditor.cs
@@ -0,0 +1,30 @@
+using GameLovers.UiService;
+using UnityEditor;
+
+namespace GameLoversEditor.UiService
+{
+	/// <summary>
+	/// Default UI Set identifiers for out-of-the-box usage.
+	/// Users can create their own enum and custom editor to override these defaults.
+	/// </summary>
+	public enum DefaultUiSetId
+	{
+		InitialLoading = 0,
+		MainMenu = 1,
+		Gameplay = 2,
+		Settings = 3,
+		Overlays = 4,
+		Popups = 5
+	}
+
+	/// <summary>
+	/// Default implementation of the UiConfigs editor.
+	/// This allows the library to work out-of-the-box without requiring user implementation.
+	/// Users can override by creating their own CustomEditor implementation for UiConfigs.
+	/// </summary>
+	[CustomEditor(typeof(UiConfigs))]
+	public class DefaultUiConfigsEditor : UiConfigsEditor<DefaultUiSetId>
+	{
+		// No additional implementation needed - uses base class functionality
+	}
+}
\ No newline at end of file
diff --git a/Editor/DefaultUiConfigsEditor.cs.meta b/Editor/DefaultUiConfigsEditor.cs.meta
new file mode 100644
index 0000000..5a2689d
--- /dev/null
+++ b/Editor/DefaultUiConfigsEditor.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 59b150f8c9ed42b6b3113f2ff0c7b63b
+timeCreated: 1762120608
\ No newline at end of file
diff --git a/Editor/NonDrawingViewEditor.cs b/Editor/NonDrawingViewEditor.cs
index a5a5f35..96b1a68 100644
--- a/Editor/NonDrawingViewEditor.cs
+++ b/Editor/NonDrawingViewEditor.cs
@@ -1,7 +1,8 @@
 using GameLovers.UiService.Views;
 using UnityEditor;
 using UnityEditor.UI;
-using UnityEngine;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
 
 // ReSharper disable once CheckNamespace
 
@@ -13,14 +14,25 @@ namespace GameLoversEditor.UiService
 	[CanEditMultipleObjects, CustomEditor(typeof(NonDrawingView), false)]
 	public class NonDrawingViewEditor : GraphicEditor
 	{
-		public override void OnInspectorGUI ()
+		public override VisualElement CreateInspectorGUI()
 		{
-			serializedObject.Update();
-			EditorGUILayout.PropertyField(m_Script, new GUILayoutOption[0]);
-			
-			// skipping AppearanceControlsGUI
-			RaycastControlsGUI();
-			serializedObject.ApplyModifiedProperties();
+			var root = new VisualElement();
+
+			// Add script field
+			var scriptField = new PropertyField(serializedObject.FindProperty("m_Script"));
+			scriptField.SetEnabled(false);
+			root.Add(scriptField);
+
+			// Add raycast controls using IMGUI container since it's from base class
+			var raycastContainer = new IMGUIContainer(() =>
+			{
+				serializedObject.Update();
+				RaycastControlsGUI();
+				serializedObject.ApplyModifiedProperties();
+			});
+			root.Add(raycastContainer);
+
+			return root;
 		}
 	}
 }
\ No newline at end of file
diff --git a/Editor/UiAnalyticsWindow.cs b/Editor/UiAnalyticsWindow.cs
new file mode 100644
index 0000000..35af5a1
--- /dev/null
+++ b/Editor/UiAnalyticsWindow.cs
@@ -0,0 +1,338 @@
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+using GameLovers.UiService;
+
+// ReSharper disable once CheckNamespace
+
+namespace GameLoversEditor.UiService
+{
+	/// <summary>
+	/// Editor window for viewing UI analytics and performance metrics.
+	/// This window uses UiService.CurrentAnalytics (internal) to access the analytics instance
+	/// from the currently active UiService in play mode.
+	/// Note: CurrentAnalytics is internal and only accessible to editor code within this package.
+	/// </summary>
+	public class UiAnalyticsWindow : EditorWindow
+	{
+		private bool _autoRefresh = true;
+		private double _lastRefreshTime;
+		private const double RefreshInterval = 1.0; // seconds
+		
+		private ScrollView _scrollView;
+		private VisualElement _contentContainer;
+		private Label _footerStats;
+
+		[MenuItem("Tools/UI Service/Analytics")]
+		public static void ShowWindow()
+		{
+			var window = GetWindow<UiAnalyticsWindow>("UI Analytics");
+			window.minSize = new Vector2(500, 300);
+			window.Show();
+		}
+
+		// ReSharper disable once UnusedMember.Local
+		private void OnEnable()
+		{
+			EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+		}
+
+		// ReSharper disable once UnusedMember.Local
+		private void OnDisable()
+		{
+			EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+		}
+
+		private void OnPlayModeStateChanged(PlayModeStateChange state)
+		{
+			if (rootVisualElement != null)
+			{
+				UpdateContent();
+			}
+		}
+
+		private void CreateGUI()
+		{
+			var root = rootVisualElement;
+			root.Clear();
+			
+			// Header
+			var header = CreateHeader();
+			root.Add(header);
+			
+			// Content container
+			_contentContainer = new VisualElement();
+			root.Add(_contentContainer);
+			
+			// Scroll view
+			_scrollView = new ScrollView();
+			_scrollView.style.flexGrow = 1;
+			_contentContainer.Add(_scrollView);
+			
+			// Footer
+			var footer = CreateFooter();
+			root.Add(footer);
+			
+			// Update content
+			UpdateContent();
+			
+			// Schedule periodic updates
+			root.schedule.Execute(() =>
+			{
+				if (_autoRefresh && Application.isPlaying && EditorApplication.timeSinceStartup - _lastRefreshTime > RefreshInterval)
+				{
+					_lastRefreshTime = EditorApplication.timeSinceStartup;
+					UpdateContent();
+				}
+			}).Every(100);
+		}
+
+		private VisualElement CreateHeader()
+		{
+			var header = new VisualElement();
+			header.style.flexDirection = FlexDirection.Row;
+			header.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
+			header.style.paddingTop = 5;
+			header.style.paddingBottom = 5;
+			header.style.paddingLeft = 5;
+			header.style.paddingRight = 5;
+			header.style.marginBottom = 5;
+			
+			var titleLabel = new Label("UI Service Analytics");
+			titleLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			titleLabel.style.flexGrow = 1;
+			header.Add(titleLabel);
+			
+			// Auto refresh toggle
+			var autoRefreshToggle = new Toggle("Auto Refresh") { value = _autoRefresh };
+			autoRefreshToggle.RegisterValueChangedCallback(evt => _autoRefresh = evt.newValue);
+			autoRefreshToggle.style.width = 110;
+			header.Add(autoRefreshToggle);
+			
+			// Refresh button
+			var refreshButton = new Button(() => UpdateContent()) { text = "Refresh" };
+			refreshButton.style.width = 60;
+			refreshButton.style.marginLeft = 5;
+			header.Add(refreshButton);
+			
+			// Clear button
+			var clearButton = new Button(() => GetCurrentAnalytics()?.Clear()) { text = "Clear" };
+			clearButton.style.width = 50;
+			clearButton.style.marginLeft = 5;
+			header.Add(clearButton);
+			
+			return header;
+		}
+
+		private void UpdateContent()
+		{
+			if (_scrollView == null)
+				return;
+			
+			_scrollView.Clear();
+			
+			if (!Application.isPlaying)
+			{
+				var helpBox = new HelpBox(
+					"UI Analytics is only available in Play Mode.\n\n" +
+					"Enter Play Mode to see performance metrics and event tracking.",
+					HelpBoxMessageType.Info);
+				_scrollView.Add(helpBox);
+				UpdateFooter();
+				return;
+			}
+
+			var analytics = GetCurrentAnalytics();
+			
+			if (analytics == null)
+			{
+				var warningBox = new HelpBox("No UiService instance found. (NullAnalytics is used by default)\n" +
+				"Create a UiService with UiAnalytics to enable analytics tracking. (e.g. var uiService = new UiService(new UiAssetLoader(), new UiAnalytics());)", HelpBoxMessageType.Warning);
+				_scrollView.Add(warningBox);
+				UpdateFooter();
+				return;
+			}
+			
+			var metrics = analytics.PerformanceMetrics;
+			
+			if (metrics.Count == 0)
+			{
+				var infoBox = new HelpBox("No analytics data collected yet. Use the UI Service to generate data.", HelpBoxMessageType.Info);
+				_scrollView.Add(infoBox);
+				UpdateFooter();
+				return;
+			}
+
+			var trackedLabel = new Label($"Tracked UIs: {metrics.Count}");
+			trackedLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			trackedLabel.style.marginBottom = 5;
+			trackedLabel.style.marginLeft = 5;
+			_scrollView.Add(trackedLabel);
+
+			// Sort by total lifetime
+			var sortedMetrics = metrics.Values.OrderByDescending(m => m.TotalLifetime).ToList();
+
+			foreach (var metric in sortedMetrics)
+			{
+				var card = CreateMetricCard(metric);
+				_scrollView.Add(card);
+			}
+			
+			UpdateFooter();
+		}
+
+		private VisualElement CreateMetricCard(UiPerformanceMetrics metric)
+		{
+			var card = new VisualElement();
+			card.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.3f);
+			card.style.borderTopLeftRadius = 4;
+			card.style.borderTopRightRadius = 4;
+			card.style.borderBottomLeftRadius = 4;
+			card.style.borderBottomRightRadius = 4;
+			card.style.marginLeft = 5;
+			card.style.marginRight = 5;
+			card.style.marginBottom = 5;
+			card.style.paddingTop = 8;
+			card.style.paddingBottom = 8;
+			card.style.paddingLeft = 10;
+			card.style.paddingRight = 10;
+			
+			// Header
+			var header = new Label(metric.UiName);
+			header.style.unityFontStyleAndWeight = FontStyle.Bold;
+			header.style.fontSize = 13;
+			header.style.marginBottom = 8;
+			card.Add(header);
+			
+			// Performance metrics
+			card.Add(CreateMetricRow("Load Duration:", $"{metric.LoadDuration:F3}s", GetLoadColor(metric.LoadDuration)));
+			card.Add(CreateMetricRow("Open Duration:", $"{metric.OpenDuration:F3}s", GetOpenColor(metric.OpenDuration)));
+			card.Add(CreateMetricRow("Close Duration:", $"{metric.CloseDuration:F3}s", GetCloseColor(metric.CloseDuration)));
+			
+			card.Add(CreateSpacer(5));
+			
+			card.Add(CreateMetricRow("Open Count:", metric.OpenCount.ToString(), Color.white));
+			card.Add(CreateMetricRow("Close Count:", metric.CloseCount.ToString(), Color.white));
+			card.Add(CreateMetricRow("Total Lifetime:", $"{metric.TotalLifetime:F1}s", Color.cyan));
+			
+			if (metric.FirstOpened != System.DateTime.MinValue)
+			{
+				card.Add(CreateSpacer(5));
+				card.Add(CreateMetricRow("First Opened:", metric.FirstOpened.ToString("HH:mm:ss"), Color.white));
+			}
+			
+			if (metric.LastClosed != System.DateTime.MinValue)
+			{
+				card.Add(CreateMetricRow("Last Closed:", metric.LastClosed.ToString("HH:mm:ss"), Color.white));
+			}
+			
+			return card;
+		}
+
+		private VisualElement CreateMetricRow(string label, string value, Color color)
+		{
+			var row = new VisualElement();
+			row.style.flexDirection = FlexDirection.Row;
+			row.style.marginBottom = 2;
+			
+			var labelElement = new Label(label);
+			labelElement.style.width = 150;
+			labelElement.style.marginLeft = 10;
+			row.Add(labelElement);
+			
+			var valueElement = new Label(value);
+			valueElement.style.unityFontStyleAndWeight = FontStyle.Bold;
+			valueElement.style.color = color;
+			row.Add(valueElement);
+			
+			return row;
+		}
+
+		private VisualElement CreateFooter()
+		{
+			var footer = new VisualElement();
+			footer.style.flexDirection = FlexDirection.Row;
+			footer.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
+			footer.style.paddingTop = 5;
+			footer.style.paddingBottom = 5;
+			footer.style.paddingLeft = 5;
+			footer.style.paddingRight = 5;
+			footer.style.marginTop = 5;
+			
+			_footerStats = new Label();
+			_footerStats.style.flexGrow = 1;
+			footer.Add(_footerStats);
+			
+			var logButton = new Button(() => GetCurrentAnalytics()?.LogPerformanceSummary()) { text = "Log Summary" };
+			logButton.style.width = 100;
+			footer.Add(logButton);
+			
+			return footer;
+		}
+
+		private void UpdateFooter()
+		{
+			if (_footerStats == null)
+				return;
+			
+			var analytics = GetCurrentAnalytics();
+			if (analytics != null)
+			{
+				var metrics = analytics.PerformanceMetrics;
+				if (metrics.Count > 0)
+				{
+					var totalOpens = metrics.Values.Sum(m => m.OpenCount);
+					var totalCloses = metrics.Values.Sum(m => m.CloseCount);
+					_footerStats.text = $"Total Opens: {totalOpens} | Total Closes: {totalCloses}";
+				}
+				else
+				{
+					_footerStats.text = "";
+				}
+			}
+			else
+			{
+				_footerStats.text = "";
+			}
+		}
+
+		private VisualElement CreateSpacer(int height)
+		{
+			var spacer = new VisualElement();
+			spacer.style.height = height;
+			return spacer;
+		}
+
+		/// <summary>
+		/// Helper method to get the current analytics instance from the active UiService.
+		/// Note: This accesses an internal property only available to editor code within this package.
+		/// </summary>
+		private IUiAnalytics GetCurrentAnalytics()
+		{
+			return GameLovers.UiService.UiService.CurrentAnalytics;
+		}
+
+		private Color GetLoadColor(float duration)
+		{
+			if (duration < 0.1f) return Color.green;
+			if (duration < 0.5f) return Color.yellow;
+			return Color.red;
+		}
+
+		private Color GetOpenColor(float duration)
+		{
+			if (duration < 0.05f) return Color.green;
+			if (duration < 0.2f) return Color.yellow;
+			return Color.red;
+		}
+
+		private Color GetCloseColor(float duration)
+		{
+			if (duration < 0.05f) return Color.green;
+			if (duration < 0.2f) return Color.yellow;
+			return Color.red;
+		}
+	}
+}
+
diff --git a/Editor/UiAnalyticsWindow.cs.meta b/Editor/UiAnalyticsWindow.cs.meta
new file mode 100644
index 0000000..c14bf6f
--- /dev/null
+++ b/Editor/UiAnalyticsWindow.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1997986c632194915931f1948be974f5
\ No newline at end of file
diff --git a/Editor/UiConfigsEditor.cs b/Editor/UiConfigsEditor.cs
index 95ba248..d985e9f 100644
--- a/Editor/UiConfigsEditor.cs
+++ b/Editor/UiConfigsEditor.cs
@@ -1,10 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using GameLovers.UiService;
 using UnityEditor;
 using UnityEditor.AddressableAssets;
 using UnityEditor.AddressableAssets.Settings;
-using UnityEditorInternal;
+using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
 
@@ -15,10 +16,9 @@ namespace GameLoversEditor.UiService
 	/// <summary>
 	/// Helps selecting the <see cref="UiConfigs"/> asset file in the Editor
 	/// </summary>
-	public static class UiConfigsSelect
+	public static class UiConfigsMenuItems
 	{
-		
-		[MenuItem("Tools/Select UiConfigs.asset")]
+		[MenuItem("Tools/UI Service/Select UiConfigs")]
 		private static void SelectUiConfigs()
 		{
 			var assets = AssetDatabase.FindAssets($"t:{nameof(UiConfigs)}");
@@ -34,9 +34,33 @@ private static void SelectUiConfigs()
 			}
 
 			Selection.activeObject = scriptableObject;
+			FocusInspectorWindow();
+		}
+
+		[MenuItem("Tools/UI Service/Layer Visualizer")]
+		public static void ShowLayerVisualizer()
+		{
+			// Set the pref BEFORE selecting so OnEnable reads the correct value
+			EditorPrefs.SetBool("UiConfigsEditor_ShowVisualizer", true);
+			
+			SelectUiConfigs();
+
+			// Force inspector refresh to rebuild the UI
+			ActiveEditorTracker.sharedTracker.ForceRebuild();
+		}
+		
+		private static void FocusInspectorWindow()
+		{
+			// Get the Inspector window type using reflection
+			var inspectorType = typeof(Editor).Assembly.GetType("UnityEditor.InspectorWindow");
+			if (inspectorType != null)
+			{
+				// Focus or create the Inspector window
+				EditorWindow.GetWindow(inspectorType);
+			}
 		}
 	}
-	
+
 	/// <summary>
 	/// Improves the inspector visualization for the <see cref="UiConfigs"/> scriptable object
 	/// </summary>
@@ -53,247 +77,862 @@ private static void SelectUiConfigs()
 	public abstract class UiConfigsEditor<TSet> : Editor
 		where TSet : Enum
 	{
-		private readonly List<string> _assetsPath = new List<string>();
-		private readonly List<string> _uiConfigsType = new List<string>();
-		private readonly List<ReorderableList> _setsConfigsList = new List<ReorderableList>();
-		private readonly GUIContent _uiConfigGuiContent = new GUIContent("Ui Config",
-			"All the Addressable addresses for every UiPresenter in the game.\n" +
-			"The second field is the layer where the UiPresenter should be shown. " +
-			"The higher the value, the closer is the UiPresenter to the camera.\n" +
-			"If the UiPresenter contains a Canvas/UIDocument in the root, the layer value is the same of the UI sorting order");
-		private readonly GUIContent _uiSetConfigGuiContent = new GUIContent("Ui Set",
-			"All the Ui Sets in the game.\n" +
-			"A UiSet groups a list of UiConfigs and shows them all at the same time via the UiService.\n" +
-			"The UiConfigs are all loaded in the order they are configured. Top = first; Bottom = Last");
-
-		private string[] _uiConfigsAddress;
+		private const string UiConfigExplanation = 
+			"UI Presenter Configurations\n\n" +
+			"Lists all Addressable UI Presenter prefabs in the game with their sorting layer values. " +
+			"The Layer field controls the rendering order - higher values appear closer to the camera. " +
+			"For presenters with Canvas or UIDocument components, this value directly maps to the UI sorting order.";
+
+		private const string UiSetExplanation =
+			"UI Set Configurations\n\n" +
+			"UI Sets group multiple presenter instances that should be displayed together. " +
+			"When a set is activated via UiService, all its presenters are loaded and shown simultaneously. " +
+			"Presenters are loaded in the order listed (top to bottom).\n\n" +
+			"Each UI's instance address is automatically set to its Addressable address from the config.";
+
+		private const string VisualizerPrefsKey = "UiConfigsEditor_ShowVisualizer";
+
+		private Dictionary<string, string> _assetPathLookup;
+		private List<string> _uiConfigsAddress;
+		private Dictionary<string, Type> _uiTypesByAddress; // Maps addressable address to Type
+		private UiConfigs _scriptableObject;
 		private SerializedProperty _configsProperty;
 		private SerializedProperty _setsProperty;
-		private ReorderableList _configList;
-		private ReorderableList _setList;
-		private bool _resetValues;
-		private UiConfigs _scriptableObject;
+		private bool _showVisualizer;
+		private VisualElement _visualizerContainer;
+		private string _visualizerSearchFilter = "";
 
 		private void OnEnable()
 		{
-			_resetValues = false;
-
-			InitConfigValues();
-			InitReorderableLists();
+			_scriptableObject = target as UiConfigs;
+			if (_scriptableObject == null)
+			{
+				return;
+			}
 
-			_setList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, $"Ui {nameof(UiConfigs.Sets)}");
-			_setList.elementHeightCallback = index => _setsConfigsList[index].GetHeight();
-			_setList.drawElementCallback = (rect, index, active, focused) => _setsConfigsList[index].DoList(rect);
-			_configList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, $"Ui {nameof(UiConfigs.Configs)}");
-			_configList.drawElementCallback = DrawUiConfigElement;
+			SyncConfigsWithAddressables();
+			
+			// Ensure sets array matches enum size
+			_scriptableObject.SetSetsSize(Enum.GetNames(typeof(TSet)).Length);
+			
+			// Update the serializedObject to reflect the changes
+			serializedObject.Update();
+			
+			_configsProperty = serializedObject.FindProperty("_configs");
+			_setsProperty = serializedObject.FindProperty("_sets");
+			
+			// Load visualizer visibility state
+			_showVisualizer = EditorPrefs.GetBool(VisualizerPrefsKey, false);
+		}
+		
+		/// <summary>
+		/// Public method to show the visualizer, used by menu items
+		/// </summary>
+		public static void ShowVisualizerForConfigs(UiConfigs configs)
+		{
+			if (configs == null) return;
+			
+			Selection.activeObject = configs;
+			EditorPrefs.SetBool(VisualizerPrefsKey, true);
 		}
 
 		/// <inheritdoc />
-		public override void OnInspectorGUI()
+		public override VisualElement CreateInspectorGUI()
 		{
-			serializedObject.Update();
+			var root = new VisualElement();
+			root.style.paddingTop = 5;
+			root.style.paddingBottom = 5;
+			root.style.paddingLeft = 3;
+			root.style.paddingRight = 3;
+
+			// Section 0: Layer Visualizer (collapsible)
+			var visualizerSection = CreateVisualizerSection();
+			root.Add(visualizerSection);
+
+			// Section 1: UI Config Explanation
+			var configHelpBox = new HelpBox(UiConfigExplanation, HelpBoxMessageType.Info);
+			configHelpBox.style.marginBottom = 10;
+			root.Add(configHelpBox);
+
+			// Section 2: UI Configs List
+			var configsListView = CreateConfigsListView();
+			root.Add(configsListView);
+
+			// Section 3: Separator
+			var separator = new VisualElement();
+			separator.style.height = 1;
+			separator.style.backgroundColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
+			separator.style.marginTop = 15;
+			separator.style.marginBottom = 15;
+			root.Add(separator);
+
+			// Section 4: UI Set Explanation
+			var setHelpBox = new HelpBox(UiSetExplanation, HelpBoxMessageType.Info);
+			setHelpBox.style.marginBottom = 10;
+			root.Add(setHelpBox);
+
+			// Section 5: UI Sets List
+			var setsContainer = CreateSetsContainer();
+			root.Add(setsContainer);
+
+			return root;
+		}
 
-			LoadingSpinnerLayout();
+		private ListView CreateConfigsListView()
+		{
+			var listView = new ListView
+			{
+				showBorder = true,
+				showFoldoutHeader = true,
+				headerTitle = "UI Presenter Configs",
+				showAddRemoveFooter = false,
+				showBoundCollectionSize = false,
+				reorderable = false,
+				virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight,
+				fixedItemHeight = 22
+			};
 
-			EditorGUILayout.Space();
-			EditorGUILayout.HelpBox(_uiConfigGuiContent.tooltip, MessageType.Info);
-			_configList.DoLayoutList();
-			EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
-			EditorGUILayout.Space();
-			EditorGUILayout.HelpBox(_uiSetConfigGuiContent.tooltip, MessageType.Info);
-			_setList.DoLayoutList();
+			listView.style.minHeight = 20;
+			listView.style.marginBottom = 5;
 
-			serializedObject.ApplyModifiedProperties();
+			listView.BindProperty(_configsProperty);
 
-			if (_resetValues)
-			{
-				OnEnable();
-			}
+			listView.makeItem = CreateConfigElement;
+			listView.bindItem = BindConfigElement;
+
+			return listView;
 		}
 
-		private void LoadingSpinnerLayout()
+		private void BindConfigElement(VisualElement element, int index)
 		{
-			var uiPresentersNames = new List<string> { "<None>" };
-			var uiPresentersAssemblyNames = new List<string> { "<None>" };
+			if (index >= _configsProperty.arraySize)
+				return;
 
-			foreach (var uiConfig in _scriptableObject.Configs)
-			{
-				uiPresentersNames.Add(uiConfig.UiType.Name);
-				uiPresentersAssemblyNames.Add(uiConfig.UiType.AssemblyQualifiedName);
-			}
+			var itemProperty = _configsProperty.GetArrayElementAtIndex(index);
+			var addressProperty = itemProperty.FindPropertyRelative(nameof(UiConfigs.UiConfigSerializable.AddressableAddress));
+			var layerProperty = itemProperty.FindPropertyRelative(nameof(UiConfigs.UiConfigSerializable.Layer));
+
+			var label = element.Q<Label>();
+			var layerField = element.Q<IntegerField>();
+
+			label.text = addressProperty.stringValue;
+			
+			// Unbind to remove previous event handlers
+			layerField.Unbind();
+			
+			// Bind to property for automatic serialization
+			layerField.BindProperty(layerProperty);
+			
+			// Register custom callback for prefab sync (using userData to store address for later)
+			layerField.userData = addressProperty.stringValue;
+			layerField.RegisterValueChangedCallback(OnLayerChanged);
+		}
 
-			var selectedIndex = 0;
-			if (_scriptableObject.LoadingSpinnerType != null)
+		private void OnLayerChanged(ChangeEvent<int> evt)
+		{
+			if (evt.newValue == evt.previousValue)
+				return;
+
+			var layerField = evt.target as IntegerField;
+			if (layerField?.userData is string address)
 			{
-				selectedIndex = uiPresentersAssemblyNames.FindIndex(uiPresenterName =>
-																		_scriptableObject.LoadingSpinnerTypeString ==
-																		uiPresenterName);
-				selectedIndex = Math.Max(selectedIndex, 0);
+				// Sync with Canvas/UIDocument sorting order
+				SyncLayerToPrefab(address, evt.newValue);
 			}
-
-			selectedIndex = EditorGUILayout.Popup("Loading Spinner Presenter", selectedIndex, uiPresentersNames.ToArray());
-			_scriptableObject.LoadingSpinnerTypeString =
-				selectedIndex == 0 ? null : uiPresentersAssemblyNames[selectedIndex];
 		}
 
-		private void InitConfigValues()
+		private VisualElement CreateSetsContainer()
 		{
-			var assetList = GetAssetList();
-			var gameObjectType = typeof(GameObject);
-			var uiConfigsAddress = new List<string>();
-			var configs = new List<UiConfig>();
-			_scriptableObject = target as UiConfigs;
-
-			_uiConfigsType.Clear();
-			_assetsPath.Clear();
+			var container = new VisualElement();
+			var enumNames = Enum.GetNames(typeof(TSet));
 
-			if (_scriptableObject == null)
+			for (int setIndex = 0; setIndex < enumNames.Length; setIndex++)
 			{
-				throw new NullReferenceException($"The Object is not of type {nameof(UiConfigs)}");
+				var setElement = CreateSetElement(enumNames[setIndex], setIndex);
+				container.Add(setElement);
 			}
 
-			var configsCache = _scriptableObject.Configs;
+			return container;
+		}
 
-			for (int i = 0; i < assetList.Count; i++)
-			{
-				var assetAddress = assetList[i].address;
+		private VisualElement CreateConfigElement()
+		{
+			var container = new VisualElement();
+			container.style.flexDirection = FlexDirection.Row;
+			container.style.alignItems = Align.Center;
+			container.style.paddingTop = 2;
+			container.style.paddingBottom = 2;
+
+			// UiPresenter Addressable Address
+			var label = new Label();
+			label.style.flexGrow = 1;
+			label.style.paddingLeft = 5;
+			label.style.unityTextAlign = TextAnchor.MiddleLeft;
+			container.Add(label);
+
+			// Layer field
+			var layerField = new IntegerField();
+			layerField.style.width = 80;
+			layerField.style.marginRight = 5;
+			container.Add(layerField);
+
+			return container;
+		}
 
-				if (AssetDatabase.GetMainAssetTypeAtPath(assetList[i].AssetPath) != gameObjectType)
-				{
-					continue;
-				}
+		private VisualElement CreateSetPresenterElement()
+		{
+			var container = new VisualElement();
+			container.style.flexDirection = FlexDirection.Row;
+			container.style.alignItems = Align.Center;
+			
+			// Drag handle for reordering
+			var dragHandle = new Label("☰");
+			dragHandle.style.width = 20;
+			dragHandle.style.unityTextAlign = TextAnchor.MiddleCenter;
+			dragHandle.style.marginLeft = 3;
+			dragHandle.style.marginRight = 5;
+			dragHandle.style.fontSize = 16;
+			dragHandle.style.color = new Color(0.7f, 0.7f, 0.7f);
+			dragHandle.tooltip = "Drag to reorder";
+			container.Add(dragHandle);
+			
+			// Dropdown for selecting UI presenter type
+			var dropdown = new DropdownField();
+			dropdown.choices = new List<string>(_uiConfigsAddress ?? new List<string>());
+			dropdown.style.flexGrow = 1;
+			dropdown.style.paddingTop = 3;
+			dropdown.style.paddingBottom = 3;
+			dropdown.name = "ui-type-dropdown";
+			container.Add(dropdown);
+			
+			// Delete button
+			var deleteButton = new Button { text = "×" };
+			deleteButton.style.width = 25;
+			deleteButton.style.height = 20;
+			deleteButton.style.marginLeft = 5;
+			deleteButton.style.marginRight = 3;
+			deleteButton.style.fontSize = 18;
+			deleteButton.style.unityFontStyleAndWeight = FontStyle.Bold;
+			deleteButton.tooltip = "Remove from set";
+			deleteButton.name = "delete-button";
+			container.Add(deleteButton);
+			
+			return container;
+		}
 
-				var uiPresenter = AssetDatabase.LoadAssetAtPath<UiPresenter>(assetList[i].AssetPath);
+		private VisualElement CreateSetElement(string setName, int setIndex)
+		{
+			var setContainer = new VisualElement();
+			setContainer.style.paddingLeft = 5;
+			setContainer.style.paddingRight = 5;
+			setContainer.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.2f);
+			setContainer.style.borderBottomLeftRadius = 4;
+			setContainer.style.borderBottomRightRadius = 4;
+			setContainer.style.borderTopLeftRadius = 4;
+			setContainer.style.borderTopRightRadius = 4;
+
+			// Header
+			var header = new Label($"{setName} Set");
+			header.style.unityFontStyleAndWeight = FontStyle.Bold;
+			header.style.fontSize = 13;
+			header.style.marginBottom = 5;
+			setContainer.Add(header);
+
+			// Get the property for this set's UI entries
+			var setProperty = _setsProperty.GetArrayElementAtIndex(setIndex);
+			var uiEntriesProperty = setProperty.FindPropertyRelative(nameof(UiSetConfigSerializable.UiEntries));
+
+			// ListView for presenters in this set
+			var presenterListView = new ListView
+			{
+				showBorder = true,
+				showAddRemoveFooter = true,
+				reorderable = true,
+				showBoundCollectionSize = false,
+				virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight,
+				fixedItemHeight = 28
+			};
+
+			presenterListView.BindProperty(uiEntriesProperty);
+
+			presenterListView.makeItem = CreateSetPresenterElement;
+			presenterListView.bindItem = (element, index) => BindSetPresenterElement(element, index, uiEntriesProperty, presenterListView);
+			
+			// Register callbacks to save changes when items are added, removed, or reordered
+			presenterListView.itemsAdded += indices => OnPresenterItemsAdded(indices, uiEntriesProperty);
+			presenterListView.itemsRemoved += _ => SaveSetChanges();
+			presenterListView.itemIndexChanged += (_, _) => SaveSetChanges();
+
+			setContainer.Add(presenterListView);
+
+			return setContainer;
+		}
 
-				if (uiPresenter == null)
-				{
-					continue;
-				}
+		private void BindSetPresenterElement(VisualElement element, int index, SerializedProperty uiEntriesProperty, ListView listView)
+		{
+			if (index >= uiEntriesProperty.arraySize)
+				return;
 
-				_assetsPath.Add(assetList[i].AssetPath);
+			var dropdown = element.Q<DropdownField>("ui-type-dropdown");
+			if (dropdown == null)
+				return;
 
-				var sortingOrder = -1;
-				if (uiPresenter.TryGetComponent<Canvas>(out var canvas))
+			var entryProperty = uiEntriesProperty.GetArrayElementAtIndex(index);
+			var typeNameProperty = entryProperty.FindPropertyRelative(nameof(UiSetEntry.UiTypeName));
+			var instanceAddressProperty = entryProperty.FindPropertyRelative(nameof(UiSetEntry.InstanceAddress));
+			
+			// Find the matching address for this type
+			var currentTypeName = typeNameProperty.stringValue;
+			Type currentType = string.IsNullOrEmpty(currentTypeName) ? null : Type.GetType(currentTypeName);
+			
+			// Find the address that matches this type
+			string matchingAddress = null;
+			if (currentType != null && _uiTypesByAddress != null)
+			{
+				foreach (var kvp in _uiTypesByAddress)
 				{
-					sortingOrder = canvas.sortingOrder;
+					if (kvp.Value == currentType)
+					{
+						matchingAddress = kvp.Key;
+						break;
+					}
 				}
-				else if (uiPresenter.TryGetComponent<UIDocument>(out var document))
+			}
+			
+			var selectedIndex = string.IsNullOrEmpty(matchingAddress) ? 0 : 
+				_uiConfigsAddress.FindIndex(address => address == matchingAddress);
+			
+			if (selectedIndex < 0) 
+				selectedIndex = 0;
+
+			if (_uiConfigsAddress != null && _uiConfigsAddress.Count > 0)
+			{
+				// Unbind to prevent stale property references
+				dropdown.Unbind();
+				
+				// Set the current values
+				dropdown.index = selectedIndex;
+				
+				// Register callback to store type and addressable address when changed
+				dropdown.RegisterValueChangedCallback(_ =>
 				{
-					sortingOrder = (int) document.sortingOrder;
-				}
+					var newIndex = dropdown.index;
+					if (newIndex >= 0 && newIndex < _uiConfigsAddress.Count)
+					{
+						var selectedAddress = _uiConfigsAddress[newIndex];
+						if (_uiTypesByAddress.TryGetValue(selectedAddress, out var selectedType))
+						{
+							typeNameProperty.stringValue = selectedType.AssemblyQualifiedName;
+							// Use the addressable address as the instance address
+							instanceAddressProperty.stringValue = selectedAddress;
+							SaveSetChanges();
+						}
+					}
+				});
 				
-				var indexMatch = configsCache.FindIndex(configCheck => configCheck.AddressableAddress == assetAddress);
-				var type = uiPresenter.GetType();
-				var config = new UiConfig
+				// Set initial value if property is empty
+				if (string.IsNullOrEmpty(typeNameProperty.stringValue) && selectedIndex < _uiConfigsAddress.Count)
 				{
-					AddressableAddress = assetList[i].address,
-					Layer = sortingOrder < 0 ? 0 : sortingOrder,
-					UiType = type,
-					LoadSynchronously = Attribute.IsDefined(type, typeof(LoadSynchronouslyAttribute))
+					var address = _uiConfigsAddress[selectedIndex];
+					if (_uiTypesByAddress.TryGetValue(address, out var type))
+					{
+						typeNameProperty.stringValue = type.AssemblyQualifiedName;
+						instanceAddressProperty.stringValue = address;
+						serializedObject.ApplyModifiedProperties();
+					}
+				}
+			}
 
-				};
+			// Setup delete button to remove this item from the set
+			var deleteButton = element.Q<Button>("delete-button");
+			if (deleteButton != null)
+			{
+				// Store the click handler in userData to unregister it later if needed
+				if (deleteButton.userData is EventCallback<ClickEvent> previousCallback)
+				{
+					deleteButton.UnregisterCallback(previousCallback);
+				}
 
-				if (indexMatch > -1)
+				EventCallback<ClickEvent> clickHandler = _ =>
 				{
-					uiConfigsAddress.Add(config.AddressableAddress);
-					_uiConfigsType.Add(config.UiType.AssemblyQualifiedName);
+					uiEntriesProperty.DeleteArrayElementAtIndex(index);
+					SaveSetChanges();
+				};
 
-					config.Layer = sortingOrder < 0 ? configsCache[indexMatch].Layer : config.Layer;
-				}
+				deleteButton.userData = clickHandler;
+				deleteButton.RegisterCallback(clickHandler);
+		}
+	}
 
-				configs.Add(config);
+		private void OnPresenterItemsAdded(IEnumerable<int> indices, SerializedProperty uiEntriesProperty)
+		{
+			if (_uiConfigsAddress == null || _uiConfigsAddress.Count == 0 || _uiTypesByAddress == null)
+			{
+				return;
 			}
 
-			_scriptableObject.Configs = configs;
-			_uiConfigsAddress = uiConfigsAddress.ToArray();
+			var defaultAddress = _uiConfigsAddress[0];
+			Type defaultType = _uiTypesByAddress.TryGetValue(defaultAddress, out var type) ? type : null;
+			
+			foreach (var index in indices)
+			{
+				if (index < uiEntriesProperty.arraySize)
+				{
+					var entryProperty = uiEntriesProperty.GetArrayElementAtIndex(index);
+					var typeNameProperty = entryProperty.FindPropertyRelative(nameof(UiSetEntry.UiTypeName));
+					var instanceAddressProperty = entryProperty.FindPropertyRelative(nameof(UiSetEntry.InstanceAddress));
+					
+					typeNameProperty.stringValue = defaultType?.AssemblyQualifiedName ?? string.Empty;
+					// Use the addressable address as the instance address
+					instanceAddressProperty.stringValue = defaultAddress;
+				}
+			}
+		
+			SaveSetChanges();
+		}
 
-			EditorUtility.SetDirty(_scriptableObject);
-			AssetDatabase.SaveAssets();
-			Resources.UnloadUnusedAssets();
+		private void SaveSetChanges()
+		{
+			serializedObject.ApplyModifiedProperties();
+			
+			if (_scriptableObject != null)
+			{
+				EditorUtility.SetDirty(_scriptableObject);
+				AssetDatabase.SaveAssets();
+			}
 		}
 
-		private void InitReorderableLists()
+		private void SyncConfigsWithAddressables()
 		{
-			var enumNames = Enum.GetNames(typeof(TSet));
-			var scriptableObject = target as UiConfigs;
+			var assetList = GetAssetList();
+			var configs = new List<UiConfig>();
+			var uiConfigsAddress = new List<string>();
+			var assetPathLookup = new Dictionary<string, string>();
+			var existingConfigs = _scriptableObject.Configs;
 
-			if (scriptableObject == null)
+			foreach (var asset in assetList)
 			{
-				throw new NullReferenceException($"The Object is not of type {nameof(UiConfigs)}");
-			}
+				// Only process GameObjects
+				if (AssetDatabase.GetMainAssetTypeAtPath(asset.AssetPath) != typeof(GameObject))
+					continue;
 
-			scriptableObject.SetSetsSize(Enum.GetNames(typeof(TSet)).Length);
+				var uiPresenter = AssetDatabase.LoadAssetAtPath<UiPresenter>(asset.AssetPath);
+				if (uiPresenter == null)
+					continue;
 
-			_configsProperty = serializedObject.FindProperty("_configs");
-			_setsProperty = serializedObject.FindProperty("_sets");
-			_configList = new ReorderableList(serializedObject, _configsProperty, false, true, false, false);
-			_setList = new ReorderableList(serializedObject, _setsProperty, false, true, false, false);
+				// Get sorting order from Canvas or UIDocument
+				var sortingOrder = GetSortingOrder(uiPresenter);
+				
+				// Check if config already exists to preserve custom layer values
+				var existingConfigIndex = existingConfigs.FindIndex(c => c.AddressableAddress == asset.address);
+				var presenterType = uiPresenter.GetType();
+				
+				var config = new UiConfig
+				{
+					AddressableAddress = asset.address,
+					Layer = existingConfigIndex >= 0 && sortingOrder < 0 ? existingConfigs[existingConfigIndex].Layer : 
+					        sortingOrder < 0 ? 0 : sortingOrder,
+					UiType = presenterType,
+					LoadSynchronously = Attribute.IsDefined(presenterType, typeof(LoadSynchronouslyAttribute))
+				};
 
-			_setsConfigsList.Clear();
-			_setsConfigsList.Capacity = enumNames.Length;
-			_configList.onChangedCallback = reorderableList => _resetValues = true;
+				configs.Add(config);
+				uiConfigsAddress.Add(asset.address);
+				assetPathLookup[asset.address] = asset.AssetPath;
+			}
 
-			for (int i = 0; i < enumNames.Length; i++)
+			_scriptableObject.Configs = configs;
+			_uiConfigsAddress = uiConfigsAddress;
+			_assetPathLookup = assetPathLookup;
+			
+			// Build Type lookup dictionary
+			_uiTypesByAddress = new Dictionary<string, Type>();
+			foreach (var config in configs)
 			{
-				var property = _setsProperty.GetArrayElementAtIndex(i).FindPropertyRelative($"{nameof(UiConfigs.UiSetConfigSerializable.UiConfigsType)}");
-				var enumName = enumNames[i];
-				var list = new ReorderableList(serializedObject, property, true, true, true, true);
-
-				list.drawHeaderCallback = rect => EditorGUI.LabelField(rect, $"{enumName} Set");
-				list.onCanAddCallback = reorderableList => _configList.count > 0;
-				list.drawElementCallback = (rect, index, active, focused) =>
+				if (!string.IsNullOrEmpty(config.AddressableAddress) && config.UiType != null)
 				{
-					var serializedProperty = property.GetArrayElementAtIndex(index);
-					var typeIndex = string.IsNullOrEmpty(serializedProperty.stringValue) ?
-						0 : _uiConfigsType.FindIndex(type => type == serializedProperty.stringValue);
+					_uiTypesByAddress[config.AddressableAddress] = config.UiType;
+				}
+			}
 
-					serializedProperty.stringValue = _uiConfigsType[EditorGUI.Popup(rect, typeIndex, _uiConfigsAddress)];
-				};
+			EditorUtility.SetDirty(_scriptableObject);
+			AssetDatabase.SaveAssets();
+		}
 
-				_setsConfigsList.Add(list);
+		private int GetSortingOrder(UiPresenter presenter)
+		{
+			if (presenter.TryGetComponent<Canvas>(out var canvas))
+			{
+				return canvas.sortingOrder;
+			}
+			
+			if (presenter.TryGetComponent<UIDocument>(out var document))
+			{
+				return (int)document.sortingOrder;
 			}
+			
+			return -1;
 		}
 
-		private void DrawUiConfigElement(Rect rect, int index, bool isActive, bool isFocused)
+		private void SyncLayerToPrefab(string address, int newLayer)
 		{
-			const int layerRectWidth = 100;
-
-			var addressRect = new Rect(rect.x, rect.y, rect.width - layerRectWidth - 5, rect.height);
-			var layerRect = new Rect(addressRect.xMax + 5, rect.y, layerRectWidth, rect.height);
-			var arrayElement = _configsProperty.GetArrayElementAtIndex(index);
-			var address = arrayElement.FindPropertyRelative($"{nameof(UiConfig.AddressableAddress)}");
-			var layer = arrayElement.FindPropertyRelative($"{nameof(UiConfig.Layer)}");
-			var previousLayer = layer.intValue;
-
-			_uiConfigGuiContent.text = address.stringValue;
-
-			EditorGUI.LabelField(addressRect, _uiConfigGuiContent);
-			var newLayer = EditorGUI.IntField(layerRect, previousLayer);
+			if (_assetPathLookup == null || !_assetPathLookup.TryGetValue(address, out var assetPath))
+				return;
 
-			if (newLayer == previousLayer)
-			{
+			var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+			if (prefab == null)
 				return;
-			}
 
-			layer.intValue = newLayer;
+			bool changed = false;
 
-			var ui = AssetDatabase.LoadAssetAtPath<GameObject>(_assetsPath[index]);
-			if (ui.TryGetComponent<Canvas>(out var canvas))
+			if (prefab.TryGetComponent<Canvas>(out var canvas))
 			{
 				canvas.sortingOrder = newLayer;
-
-				EditorUtility.SetDirty(canvas);
-				AssetDatabase.SaveAssets();
+				changed = true;
 			}
-			else if (ui.TryGetComponent<UIDocument>(out var document))
+			else if (prefab.TryGetComponent<UIDocument>(out var document))
 			{
 				document.sortingOrder = newLayer;
+				changed = true;
+			}
 
-				EditorUtility.SetDirty(document);
+			if (changed)
+			{
+				EditorUtility.SetDirty(prefab);
 				AssetDatabase.SaveAssets();
 			}
-
-			Resources.UnloadUnusedAssets();
+		}
+		
+		private VisualElement CreateVisualizerSection()
+		{
+			var section = new VisualElement();
+			section.style.marginBottom = 15;
+			
+			// Create header with toggle button
+			var header = new VisualElement();
+			header.style.flexDirection = FlexDirection.Row;
+			header.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
+			header.style.paddingTop = 5;
+			header.style.paddingBottom = 5;
+			header.style.paddingLeft = 5;
+			header.style.paddingRight = 5;
+			header.style.borderTopLeftRadius = 4;
+			header.style.borderTopRightRadius = 4;
+			
+			var toggleButton = new Button(() => ToggleVisualizer())
+			{
+				text = _showVisualizer ? "▼" : "▶"
+			};
+			toggleButton.style.width = 25;
+			toggleButton.style.marginRight = 5;
+			
+			var titleLabel = new Label("UI Layer Hierarchy Visualizer");
+			titleLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			titleLabel.style.flexGrow = 1;
+			
+			header.Add(toggleButton);
+			header.Add(titleLabel);
+			section.Add(header);
+			
+			// Create visualizer container
+			_visualizerContainer = new VisualElement();
+			_visualizerContainer.style.backgroundColor = new Color(0.15f, 0.15f, 0.15f);
+			_visualizerContainer.style.paddingTop = 10;
+			_visualizerContainer.style.paddingBottom = 10;
+			_visualizerContainer.style.paddingLeft = 5;
+			_visualizerContainer.style.paddingRight = 5;
+			_visualizerContainer.style.borderBottomLeftRadius = 4;
+			_visualizerContainer.style.borderBottomRightRadius = 4;
+			_visualizerContainer.style.display = _showVisualizer ? DisplayStyle.Flex : DisplayStyle.None;
+			
+			// Add search toolbar
+			var searchToolbar = CreateVisualizerSearchToolbar();
+			_visualizerContainer.Add(searchToolbar);
+			
+			// Add visualizer content
+			var content = CreateVisualizerContent();
+			_visualizerContainer.Add(content);
+			
+			section.Add(_visualizerContainer);
+			
+			return section;
+		}
+		
+		private void ToggleVisualizer()
+		{
+			_showVisualizer = !_showVisualizer;
+			EditorPrefs.SetBool(VisualizerPrefsKey, _showVisualizer);
+			
+			if (_visualizerContainer != null)
+			{
+				_visualizerContainer.style.display = _showVisualizer ? DisplayStyle.Flex : DisplayStyle.None;
+				
+				// Update toggle button text
+				var toggleButton = _visualizerContainer.parent.Q<Button>();
+				if (toggleButton != null)
+				{
+					toggleButton.text = _showVisualizer ? "▼" : "▶";
+				}
+				
+				// Refresh content if showing
+				if (_showVisualizer)
+				{
+					RefreshVisualizerContent();
+				}
+			}
+		}
+		
+		private VisualElement CreateVisualizerSearchToolbar()
+		{
+			var toolbar = new VisualElement();
+			toolbar.style.flexDirection = FlexDirection.Row;
+			toolbar.style.backgroundColor = new Color(0.25f, 0.25f, 0.25f);
+			toolbar.style.paddingTop = 3;
+			toolbar.style.paddingBottom = 3;
+			toolbar.style.paddingLeft = 5;
+			toolbar.style.paddingRight = 5;
+			toolbar.style.marginBottom = 10;
+			toolbar.style.borderTopLeftRadius = 3;
+			toolbar.style.borderTopRightRadius = 3;
+			toolbar.style.borderBottomLeftRadius = 3;
+			toolbar.style.borderBottomRightRadius = 3;
+			
+			var spacer = new VisualElement();
+			spacer.style.flexGrow = 1;
+			toolbar.Add(spacer);
+			
+			var searchLabel = new Label("Search:");
+			searchLabel.style.marginRight = 5;
+			searchLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
+			toolbar.Add(searchLabel);
+			
+			var searchField = new ToolbarSearchField();
+			searchField.style.width = 200;
+			searchField.value = _visualizerSearchFilter;
+			searchField.RegisterValueChangedCallback(evt =>
+			{
+				_visualizerSearchFilter = evt.newValue;
+				RefreshVisualizerContent();
+			});
+			toolbar.Add(searchField);
+			
+			return toolbar;
+		}
+		
+		private ScrollView CreateVisualizerContent()
+		{
+			var scrollView = new ScrollView();
+			scrollView.style.maxHeight = 500;
+			scrollView.style.marginTop = 5;
+			
+			BuildVisualizerLayerHierarchy(scrollView);
+			
+			return scrollView;
+		}
+		
+		private void RefreshVisualizerContent()
+		{
+			if (_visualizerContainer == null)
+				return;
+				
+			var scrollView = _visualizerContainer.Q<ScrollView>();
+			if (scrollView != null)
+			{
+				scrollView.Clear();
+				BuildVisualizerLayerHierarchy(scrollView);
+			}
+		}
+		
+		private void BuildVisualizerLayerHierarchy(ScrollView scrollView)
+		{
+			var configs = _scriptableObject?.Configs;
+			if (configs == null || configs.Count == 0)
+			{
+				var infoBox = new HelpBox("No UI configurations found", HelpBoxMessageType.Info);
+				scrollView.Add(infoBox);
+				return;
+			}
+			
+			// Filter configs
+			var filteredConfigs = FilterVisualizerConfigs(configs);
+			
+			// Group by layer
+			var layerGroups = filteredConfigs
+				.GroupBy(c => c.Layer)
+				.OrderBy(g => g.Key)
+				.ToList();
+			
+			var layersContainer = new VisualElement();
+			layersContainer.style.marginLeft = 5;
+			layersContainer.style.marginRight = 5;
+			
+			foreach (var layerGroup in layerGroups)
+			{
+				var layerElement = CreateVisualizerLayerElement(layerGroup.Key, layerGroup.ToList());
+				layersContainer.Add(layerElement);
+			}
+			
+			scrollView.Add(layersContainer);
+			
+			// Statistics
+			var statsElement = CreateVisualizerStatistics(filteredConfigs);
+			scrollView.Add(statsElement);
+		}
+		
+		private List<UiConfig> FilterVisualizerConfigs(List<UiConfig> configs)
+		{
+			if (string.IsNullOrEmpty(_visualizerSearchFilter))
+			{
+				return configs;
+			}
+			
+			return configs.Where(c =>
+				c.UiType.Name.ToLower().Contains(_visualizerSearchFilter.ToLower()) ||
+				c.AddressableAddress.ToLower().Contains(_visualizerSearchFilter.ToLower())
+			).ToList();
+		}
+		
+		private VisualElement CreateVisualizerLayerElement(int layer, List<UiConfig> configs)
+		{
+			var layerColor = GetVisualizerLayerColor(layer);
+			
+			var container = new VisualElement();
+			container.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.3f);
+			container.style.borderTopLeftRadius = 4;
+			container.style.borderTopRightRadius = 4;
+			container.style.borderBottomLeftRadius = 4;
+			container.style.borderBottomRightRadius = 4;
+			container.style.marginBottom = 5;
+			container.style.paddingTop = 5;
+			container.style.paddingBottom = 5;
+			
+			// Layer header
+			var header = new VisualElement();
+			header.style.flexDirection = FlexDirection.Row;
+			header.style.backgroundColor = layerColor;
+			header.style.paddingTop = 5;
+			header.style.paddingBottom = 5;
+			header.style.paddingLeft = 10;
+			header.style.paddingRight = 10;
+			header.style.marginBottom = 5;
+			header.style.alignItems = Align.Center;
+			
+			// Create text container with shadow for better readability
+			var textContainer = new VisualElement();
+			textContainer.style.flexDirection = FlexDirection.Row;
+			textContainer.style.backgroundColor = new Color(0, 0, 0, 0.5f);
+			textContainer.style.paddingLeft = 8;
+			textContainer.style.paddingRight = 8;
+			textContainer.style.paddingTop = 3;
+			textContainer.style.paddingBottom = 3;
+			textContainer.style.borderTopLeftRadius = 3;
+			textContainer.style.borderTopRightRadius = 3;
+			textContainer.style.borderBottomLeftRadius = 3;
+			textContainer.style.borderBottomRightRadius = 3;
+			
+			var layerLabel = new Label($"Layer {layer}");
+			layerLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			layerLabel.style.fontSize = 13;
+			layerLabel.style.color = Color.white;
+			layerLabel.style.textShadow = new TextShadow
+			{
+				offset = new Vector2(1, 1),
+				blurRadius = 2,
+				color = new Color(0, 0, 0, 0.8f)
+			};
+			textContainer.Add(layerLabel);
+			
+			var countLabel = new Label($"({configs.Count} UI{(configs.Count > 1 ? "s" : "")})");
+			countLabel.style.fontSize = 11;
+			countLabel.style.color = new Color(1f, 1f, 1f);
+			countLabel.style.marginLeft = 5;
+			countLabel.style.textShadow = new TextShadow
+			{
+				offset = new Vector2(1, 1),
+				blurRadius = 2,
+				color = new Color(0, 0, 0, 0.8f)
+			};
+			textContainer.Add(countLabel);
+			
+			header.Add(textContainer);
+			container.Add(header);
+			
+			// UI items in this layer
+			foreach (var config in configs)
+			{
+				var configItem = CreateVisualizerUiConfigItem(config);
+				container.Add(configItem);
+			}
+			
+			return container;
+		}
+		
+		private VisualElement CreateVisualizerUiConfigItem(UiConfig config)
+		{
+			var item = new VisualElement();
+			item.style.flexDirection = FlexDirection.Row;
+			item.style.paddingLeft = 20;
+			item.style.paddingRight = 10;
+			item.style.paddingTop = 2;
+			item.style.paddingBottom = 2;
+			
+			// Type name
+			var typeLabel = new Label(config.UiType.Name);
+			typeLabel.style.width = 200;
+			item.Add(typeLabel);
+			
+			// Address
+			var addressLabel = new Label(config.AddressableAddress);
+			addressLabel.style.fontSize = 10;
+			addressLabel.style.color = new Color(0.7f, 0.7f, 0.7f);
+			addressLabel.style.flexGrow = 1;
+			item.Add(addressLabel);
+			
+			// Sync indicator
+			if (config.LoadSynchronously)
+			{
+				var syncLabel = new Label("[SYNC]");
+				syncLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+				syncLabel.style.width = 50;
+				syncLabel.style.color = new Color(1, 0.8f, 0);
+				item.Add(syncLabel);
+			}
+			
+			return item;
+		}
+		
+		private VisualElement CreateVisualizerStatistics(List<UiConfig> configs)
+		{
+			var container = new VisualElement();
+			container.style.marginTop = 10;
+			container.style.marginLeft = 5;
+			container.style.marginBottom = 10;
+			
+			var titleLabel = new Label("Statistics");
+			titleLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			titleLabel.style.marginBottom = 5;
+			container.Add(titleLabel);
+			
+			var statsContainer = new VisualElement();
+			statsContainer.style.marginLeft = 15;
+			
+			statsContainer.Add(new Label($"Total UIs: {configs.Count}"));
+			statsContainer.Add(new Label($"Layers Used: {configs.Select(c => c.Layer).Distinct().Count()}"));
+			statsContainer.Add(new Label($"Synchronous Loads: {configs.Count(c => c.LoadSynchronously)}"));
+			statsContainer.Add(new Label($"Async Loads: {configs.Count(c => !c.LoadSynchronously)}"));
+			
+			container.Add(statsContainer);
+			
+			return container;
+		}
+		
+		private Color GetVisualizerLayerColor(int layer)
+		{
+			if (layer < 0) return new Color(0.8f, 0.2f, 0.2f);
+			if (layer == 0) return new Color(0.3f, 0.3f, 0.3f);
+			
+			var hue = (layer * 0.1f) % 1f;
+			return Color.HSVToRGB(hue, 0.5f, 0.9f);
 		}
 		
 		private static List<AddressableAssetEntry> GetAssetList()
@@ -314,4 +953,5 @@ private static List<AddressableAssetEntry> GetAssetList()
 			return assetList;
 		}
 	}
-}
\ No newline at end of file
+}
+
diff --git a/Editor/UiPresenterEditor.cs b/Editor/UiPresenterEditor.cs
new file mode 100644
index 0000000..6810ece
--- /dev/null
+++ b/Editor/UiPresenterEditor.cs
@@ -0,0 +1,189 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+using UnityEditor.UIElements;
+using GameLovers.UiService;
+
+// ReSharper disable once CheckNamespace
+
+namespace GameLoversEditor.UiService
+{
+	/// <summary>
+	/// Custom editor for UiPresenter to show quick actions in the inspector
+	/// </summary>
+	[CustomEditor(typeof(UiPresenter), true)]
+	public class UiPresenterEditor : Editor
+	{
+		private Label _statusLabel;
+		private VisualElement _statusIndicator;
+		private VisualElement _controlsContainer;
+
+		public override VisualElement CreateInspectorGUI()
+		{
+			var root = new VisualElement();
+			
+			// Draw default inspector
+			InspectorElement.FillDefaultInspector(root, serializedObject, this);
+			
+			// Add spacing
+			root.Add(CreateSpacer(10));
+			
+			// Controls section header
+			var header = new Label("UI Presenter Controls");
+			header.style.unityFontStyleAndWeight = FontStyle.Bold;
+			header.style.fontSize = 12;
+			root.Add(header);
+			
+			root.Add(CreateSpacer(5));
+			
+			// Status display
+			var statusRow = CreateStatusDisplay();
+			root.Add(statusRow);
+			
+			root.Add(CreateSpacer(5));
+			
+			// Controls container (will be populated based on play mode)
+			_controlsContainer = new VisualElement();
+			root.Add(_controlsContainer);
+			
+			// Update controls based on play mode
+			UpdateControls();
+			
+			// Schedule periodic updates in play mode
+			root.schedule.Execute(() =>
+			{
+				if (target != null)
+				{
+					UpdateStatusDisplay();
+				}
+			}).Every(100);
+			
+			return root;
+		}
+
+		private VisualElement CreateStatusDisplay()
+		{
+			var container = new VisualElement();
+			container.style.flexDirection = FlexDirection.Row;
+			container.style.alignItems = Align.Center;
+			
+			var statusLabel = new Label("Status:");
+			statusLabel.style.width = 100;
+			container.Add(statusLabel);
+			
+			// Status indicator circle
+			_statusIndicator = new VisualElement();
+			_statusIndicator.style.width = 12;
+			_statusIndicator.style.height = 12;
+			_statusIndicator.style.borderTopLeftRadius = 6;
+			_statusIndicator.style.borderTopRightRadius = 6;
+			_statusIndicator.style.borderBottomLeftRadius = 6;
+			_statusIndicator.style.borderBottomRightRadius = 6;
+			_statusIndicator.style.marginRight = 5;
+			container.Add(_statusIndicator);
+			
+			// Status text
+			_statusLabel = new Label();
+			_statusLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			container.Add(_statusLabel);
+			
+			UpdateStatusDisplay();
+			
+			return container;
+		}
+
+		private void UpdateStatusDisplay()
+		{
+			var presenter = (UiPresenter)target;
+			if (presenter == null)
+				return;
+			
+			var isOpen = presenter.IsOpen;
+			_statusLabel.text = isOpen ? "OPEN" : "CLOSED";
+			_statusIndicator.style.backgroundColor = isOpen ? new Color(0, 1, 0) : new Color(1, 0, 0);
+		}
+
+		private void UpdateControls()
+		{
+			_controlsContainer.Clear();
+			
+			var presenter = (UiPresenter)target;
+			if (presenter == null)
+				return;
+			
+			if (Application.isPlaying)
+			{
+				CreatePlayModeControls();
+			}
+			else
+			{
+				var helpBox = new HelpBox("UI controls are only available in Play Mode", HelpBoxMessageType.Info);
+				_controlsContainer.Add(helpBox);
+			}
+		}
+
+		private void CreatePlayModeControls()
+		{
+			var presenter = (UiPresenter)target;
+			
+			_controlsContainer.Add(CreateSpacer(5));
+			
+			// First row of buttons
+			var row1 = new VisualElement();
+			row1.style.flexDirection = FlexDirection.Row;
+			
+			var openButton = new Button(() => presenter.gameObject.SetActive(true)) { text = "Open UI" };
+			openButton.style.flexGrow = 1;
+			openButton.style.height = 30;
+			row1.Add(openButton);
+			
+			var closeButton = new Button(() => presenter.gameObject.SetActive(false)) { text = "Close UI" };
+			closeButton.style.flexGrow = 1;
+			closeButton.style.height = 30;
+			closeButton.style.marginLeft = 5;
+			row1.Add(closeButton);
+			
+			_controlsContainer.Add(row1);
+			_controlsContainer.Add(CreateSpacer(5));
+			
+			// Destroy button
+			var closeDestroyButton = new Button(() =>
+			{
+				if (EditorUtility.DisplayDialog("Destroy UI", 
+					"Are you sure you want to destroy this UI?", "Yes", "Cancel"))
+				{
+					DestroyImmediate(presenter.gameObject);
+				}
+			}) { text = "Close & Destroy" };
+			closeDestroyButton.style.height = 25;
+			
+			_controlsContainer.Add(closeDestroyButton);
+		}
+
+		private VisualElement CreateSpacer(int height)
+		{
+			var spacer = new VisualElement();
+			spacer.style.height = height;
+			return spacer;
+		}
+
+		private void OnEnable()
+		{
+			EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+		}
+
+		private void OnDisable()
+		{
+			EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+		}
+
+		private void OnPlayModeStateChanged(PlayModeStateChange state)
+		{
+			if (_controlsContainer != null)
+			{
+				UpdateControls();
+			}
+		}
+	}
+}
+
diff --git a/Editor/UiPresenterEditor.cs.meta b/Editor/UiPresenterEditor.cs.meta
new file mode 100644
index 0000000..6d41275
--- /dev/null
+++ b/Editor/UiPresenterEditor.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 90b16c508795b46998ac7fb47211d08f
\ No newline at end of file
diff --git a/Editor/UiServiceHierarchyWindow.cs b/Editor/UiServiceHierarchyWindow.cs
new file mode 100644
index 0000000..85ec4f2
--- /dev/null
+++ b/Editor/UiServiceHierarchyWindow.cs
@@ -0,0 +1,431 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+using GameLovers.UiService;
+
+// ReSharper disable once CheckNamespace
+
+namespace GameLoversEditor.UiService
+{
+	/// <summary>
+	/// Editor window displaying active UI service hierarchy with quick controls
+	/// </summary>
+	public class UiServiceHierarchyWindow : EditorWindow
+	{
+		private bool _autoRefresh = true;
+		private double _lastRefreshTime;
+		private const double RefreshInterval = 0.5; // seconds
+		
+		private UiPresenter[] _activePresenters;
+		private Dictionary<Type, bool> _foldoutStates = new Dictionary<Type, bool>();
+		
+		private ScrollView _scrollView;
+		private Label _footerLabel;
+
+		[MenuItem("Tools/UI Service/Hierarchy Window")]
+		public static void ShowWindow()
+		{
+			var window = GetWindow<UiServiceHierarchyWindow>("UI Service Hierarchy");
+			window.minSize = new Vector2(350, 200);
+			window.Show();
+		}
+
+		private void OnEnable()
+		{
+			EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+			RefreshPresenters();
+		}
+
+		private void OnDisable()
+		{
+			EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+		}
+
+		private void OnPlayModeStateChanged(PlayModeStateChange state)
+		{
+			RefreshPresenters();
+			if (rootVisualElement != null)
+			{
+				UpdateContent();
+			}
+		}
+
+		private void CreateGUI()
+		{
+			var root = rootVisualElement;
+			root.Clear();
+			
+			// Header
+			var header = CreateHeader();
+			root.Add(header);
+			
+			// Scroll view
+			_scrollView = new ScrollView();
+			_scrollView.style.flexGrow = 1;
+			root.Add(_scrollView);
+			
+			// Footer
+			var footer = CreateFooter();
+			root.Add(footer);
+			
+			// Update content
+			UpdateContent();
+			
+			// Schedule periodic updates
+			root.schedule.Execute(() =>
+			{
+				if (_autoRefresh && Application.isPlaying && EditorApplication.timeSinceStartup - _lastRefreshTime > RefreshInterval)
+				{
+					RefreshPresenters();
+					_lastRefreshTime = EditorApplication.timeSinceStartup;
+					UpdateContent();
+				}
+			}).Every(100);
+		}
+
+		private VisualElement CreateHeader()
+		{
+			var header = new VisualElement();
+			header.style.flexDirection = FlexDirection.Row;
+			header.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
+			header.style.paddingTop = 5;
+			header.style.paddingBottom = 5;
+			header.style.paddingLeft = 5;
+			header.style.paddingRight = 5;
+			header.style.marginBottom = 5;
+			
+			var titleLabel = new Label("Active UI Hierarchy");
+			titleLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			titleLabel.style.flexGrow = 1;
+			header.Add(titleLabel);
+			
+			// Auto refresh toggle
+			var autoRefreshToggle = new Toggle("Auto Refresh") { value = _autoRefresh };
+			autoRefreshToggle.RegisterValueChangedCallback(evt => _autoRefresh = evt.newValue);
+			autoRefreshToggle.style.width = 110;
+			header.Add(autoRefreshToggle);
+			
+			// Refresh button
+			var refreshButton = new Button(() =>
+			{
+				RefreshPresenters();
+				UpdateContent();
+			}) { text = "Refresh" };
+			refreshButton.style.width = 60;
+			refreshButton.style.marginLeft = 5;
+			header.Add(refreshButton);
+			
+			return header;
+		}
+
+		private void UpdateContent()
+		{
+			if (_scrollView == null)
+				return;
+			
+			_scrollView.Clear();
+			
+			if (!Application.isPlaying)
+			{
+				var helpBox = new HelpBox(
+					"UI Service Hierarchy is only available in Play Mode.\n\n" +
+					"Enter Play Mode to see active UI presenters and control them.",
+					HelpBoxMessageType.Info);
+				_scrollView.Add(helpBox);
+				UpdateFooter();
+				return;
+			}
+
+			if (_activePresenters == null || _activePresenters.Length == 0)
+			{
+				var infoBox = new HelpBox("No active UI presenters found in the scene.", HelpBoxMessageType.Info);
+				_scrollView.Add(infoBox);
+				UpdateFooter();
+				return;
+			}
+
+			BuildPresenterHierarchy();
+			UpdateFooter();
+		}
+
+		private void BuildPresenterHierarchy()
+		{
+			var titleLabel = new Label($"Total Presenters: {_activePresenters.Length}");
+			titleLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			titleLabel.style.marginLeft = 5;
+			titleLabel.style.marginTop = 5;
+			titleLabel.style.marginBottom = 5;
+			_scrollView.Add(titleLabel);
+			
+			// Group by parent (layer)
+			var layerGroups = _activePresenters
+				.GroupBy(p => p.transform.parent != null ? p.transform.parent.gameObject : null)
+				.OrderBy(g => g.Key != null ? g.Key.name : "Root");
+
+			foreach (var group in layerGroups)
+			{
+				var layerElement = CreateLayerGroup(group.Key, group.ToArray());
+				_scrollView.Add(layerElement);
+			}
+		}
+
+		private VisualElement CreateLayerGroup(GameObject parent, UiPresenter[] presenters)
+		{
+			var layerName = parent != null ? parent.name : "Root";
+			
+			var container = new VisualElement();
+			container.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.3f);
+			container.style.borderTopLeftRadius = 4;
+			container.style.borderTopRightRadius = 4;
+			container.style.borderBottomLeftRadius = 4;
+			container.style.borderBottomRightRadius = 4;
+			container.style.marginLeft = 5;
+			container.style.marginRight = 5;
+			container.style.marginBottom = 5;
+			container.style.paddingTop = 5;
+			container.style.paddingBottom = 5;
+			
+			// Layer header
+			var header = new VisualElement();
+			header.style.flexDirection = FlexDirection.Row;
+			header.style.paddingLeft = 10;
+			header.style.paddingRight = 10;
+			header.style.marginBottom = 5;
+			
+			// Folder icon (using VisualElement as colored box)
+			var folderIcon = new VisualElement();
+			folderIcon.style.width = 16;
+			folderIcon.style.height = 16;
+			folderIcon.style.backgroundColor = new Color(0.8f, 0.7f, 0.3f);
+			folderIcon.style.borderTopLeftRadius = 2;
+			folderIcon.style.borderTopRightRadius = 2;
+			folderIcon.style.borderBottomLeftRadius = 2;
+			folderIcon.style.borderBottomRightRadius = 2;
+			folderIcon.style.marginRight = 5;
+			header.Add(folderIcon);
+			
+			var layerLabel = new Label(layerName);
+			layerLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			header.Add(layerLabel);
+			
+			var countLabel = new Label($"({presenters.Length})");
+			countLabel.style.fontSize = 11;
+			countLabel.style.color = new Color(0.7f, 0.7f, 0.7f);
+			countLabel.style.marginLeft = 5;
+			header.Add(countLabel);
+			
+			container.Add(header);
+			
+			// Presenters
+			foreach (var presenter in presenters)
+			{
+				var presenterElement = CreatePresenterItem(presenter);
+				container.Add(presenterElement);
+			}
+			
+			return container;
+		}
+
+		private VisualElement CreatePresenterItem(UiPresenter presenter)
+		{
+			var type = presenter.GetType();
+			
+			if (!_foldoutStates.ContainsKey(type))
+			{
+				_foldoutStates[type] = false;
+			}
+			
+			var container = new VisualElement();
+			container.style.backgroundColor = new Color(0.15f, 0.15f, 0.15f, 0.5f);
+			container.style.borderTopLeftRadius = 3;
+			container.style.borderTopRightRadius = 3;
+			container.style.borderBottomLeftRadius = 3;
+			container.style.borderBottomRightRadius = 3;
+			container.style.marginLeft = 10;
+			container.style.marginRight = 10;
+			container.style.marginBottom = 3;
+			container.style.paddingTop = 5;
+			container.style.paddingBottom = 5;
+			container.style.paddingLeft = 5;
+			container.style.paddingRight = 5;
+			
+			// Header with foldout
+			var headerRow = new VisualElement();
+			headerRow.style.flexDirection = FlexDirection.Row;
+			headerRow.style.alignItems = Align.Center;
+			
+			var foldout = new Foldout { value = _foldoutStates[type], text = "" };
+			foldout.RegisterValueChangedCallback(evt => _foldoutStates[type] = evt.newValue);
+			foldout.style.width = 20;
+			foldout.style.marginRight = 5;
+			headerRow.Add(foldout);
+			
+			// Status indicator (colored circle)
+			var statusIndicator = new VisualElement();
+			statusIndicator.style.width = 12;
+			statusIndicator.style.height = 12;
+			statusIndicator.style.borderTopLeftRadius = 6;
+			statusIndicator.style.borderTopRightRadius = 6;
+			statusIndicator.style.borderBottomLeftRadius = 6;
+			statusIndicator.style.borderBottomRightRadius = 6;
+			statusIndicator.style.backgroundColor = presenter.IsOpen ? new Color(0, 1, 0) : new Color(1, 0, 0);
+			statusIndicator.style.marginRight = 5;
+			headerRow.Add(statusIndicator);
+			
+			// Presenter name
+			var nameLabel = new Label(type.Name);
+			nameLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+			nameLabel.style.flexGrow = 1;
+			headerRow.Add(nameLabel);
+			
+			// Quick open/close button
+			var toggleButton = new Button(() =>
+			{
+				presenter.gameObject.SetActive(!presenter.IsOpen);
+				UpdateContent();
+			}) { text = presenter.IsOpen ? "Close" : "Open" };
+			toggleButton.style.width = 50;
+			headerRow.Add(toggleButton);
+			
+			container.Add(headerRow);
+			
+			// Expanded details
+			if (_foldoutStates[type])
+			{
+				var detailsContainer = new VisualElement();
+				detailsContainer.style.marginLeft = 25;
+				detailsContainer.style.marginTop = 5;
+				
+				detailsContainer.Add(CreateDetailRow("Type:", type.Name));
+				detailsContainer.Add(CreateDetailRow("Status:", presenter.IsOpen ? "Open" : "Closed"));
+				
+				// GameObject field
+				var gameObjectRow = new VisualElement();
+				gameObjectRow.style.flexDirection = FlexDirection.Row;
+				gameObjectRow.style.marginBottom = 2;
+				
+				var goLabel = new Label("GameObject:");
+				goLabel.style.width = 90;
+				gameObjectRow.Add(goLabel);
+				
+				var objectField = new UnityEditor.UIElements.ObjectField();
+				objectField.objectType = typeof(GameObject);
+				objectField.value = presenter.gameObject;
+				objectField.SetEnabled(false);
+				objectField.style.flexGrow = 1;
+				gameObjectRow.Add(objectField);
+				
+				detailsContainer.Add(gameObjectRow);
+				
+				// Action buttons
+				var buttonsRow = new VisualElement();
+				buttonsRow.style.flexDirection = FlexDirection.Row;
+				buttonsRow.style.marginTop = 5;
+				
+				var selectButton = new Button(() =>
+				{
+					Selection.activeGameObject = presenter.gameObject;
+					EditorGUIUtility.PingObject(presenter.gameObject);
+				}) { text = "Select in Hierarchy" };
+				selectButton.style.flexGrow = 1;
+				buttonsRow.Add(selectButton);
+				
+				var destroyButton = new Button(() =>
+				{
+					if (EditorUtility.DisplayDialog("Destroy UI",
+						$"Are you sure you want to destroy {type.Name}?", "Yes", "Cancel"))
+					{
+						DestroyImmediate(presenter.gameObject);
+						RefreshPresenters();
+						UpdateContent();
+					}
+				}) { text = "Close & Destroy" };
+				destroyButton.style.flexGrow = 1;
+				destroyButton.style.marginLeft = 5;
+				buttonsRow.Add(destroyButton);
+				
+				detailsContainer.Add(buttonsRow);
+				
+				container.Add(detailsContainer);
+			}
+			
+			return container;
+		}
+
+		private VisualElement CreateDetailRow(string label, string value)
+		{
+			var row = new VisualElement();
+			row.style.flexDirection = FlexDirection.Row;
+			row.style.marginBottom = 2;
+			
+			var labelElement = new Label(label);
+			labelElement.style.width = 90;
+			row.Add(labelElement);
+			
+			var valueElement = new Label(value);
+			row.Add(valueElement);
+			
+			return row;
+		}
+
+		private VisualElement CreateFooter()
+		{
+			var footer = new VisualElement();
+			footer.style.flexDirection = FlexDirection.Row;
+			footer.style.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
+			footer.style.paddingTop = 5;
+			footer.style.paddingBottom = 5;
+			footer.style.paddingLeft = 5;
+			footer.style.paddingRight = 5;
+			footer.style.marginTop = 5;
+			
+			_footerLabel = new Label();
+			_footerLabel.style.flexGrow = 1;
+			footer.Add(_footerLabel);
+			
+			var closeAllButton = new Button(() => CloseAllPresenters()) { text = "Close All" };
+			closeAllButton.style.width = 80;
+			footer.Add(closeAllButton);
+			
+			return footer;
+		}
+
+		private void UpdateFooter()
+		{
+			if (_footerLabel == null)
+				return;
+			
+			if (_activePresenters != null && _activePresenters.Length > 0)
+			{
+				var openCount = _activePresenters.Count(p => p != null && p.IsOpen);
+				_footerLabel.text = $"Open: {openCount} | Closed: {_activePresenters.Length - openCount}";
+			}
+			else
+			{
+				_footerLabel.text = "";
+			}
+		}
+
+		private void RefreshPresenters()
+		{
+			_activePresenters = FindObjectsByType<UiPresenter>(FindObjectsSortMode.None);
+		}
+
+		private void CloseAllPresenters()
+		{
+			if (_activePresenters == null) return;
+			
+			foreach (var presenter in _activePresenters)
+			{
+				if (presenter.IsOpen)
+				{
+					presenter.gameObject.SetActive(false);
+				}
+			}
+		}
+	}
+}
+
diff --git a/Editor/UiServiceHierarchyWindow.cs.meta b/Editor/UiServiceHierarchyWindow.cs.meta
new file mode 100644
index 0000000..0c94c00
--- /dev/null
+++ b/Editor/UiServiceHierarchyWindow.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a3734672197a24f76b95678cc3b75d6e
\ No newline at end of file
diff --git a/README.md b/README.md
index d676db1..8240de4 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 [![Unity Version](https://img.shields.io/badge/Unity-6000.0%2B-blue.svg)](https://unity3d.com/get-unity/download)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.13.0-green.svg)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.0.0-green.svg)](CHANGELOG.md)
 
 A powerful and flexible UI management system for Unity that provides a robust abstraction layer for handling game UI with support for layers, async loading, and UI sets. This service streamlines UI development by managing the complete lifecycle of UI presenters, from loading and initialization to display and cleanup.
 
@@ -11,24 +11,27 @@ A powerful and flexible UI management system for Unity that provides a robust ab
 - [Key Features](#key-features)
 - [System Requirements](#system-requirements)
 - [Installation](#installation)
+- [Package Structure](#package-structure)
+- [Dependencies](#dependencies)
 - [Quick Start](#quick-start)
 - [Core Concepts](#core-concepts)
+  - [Editor Windows](#editor-windows)
   - [UI Presenter](#ui-presenter)
+  - [Presenter Features](#presenter-features)
   - [UI Layers](#ui-layers)
   - [UI Sets](#ui-sets)
+  - [Multi-Instance Support](#multi-instance-support)
   - [UI Configuration](#ui-configuration)
 - [API Documentation](#api-documentation)
-  - [Creating UI Presenters](#creating-ui-presenters)
   - [Managing UI Lifecycle](#managing-ui-lifecycle)
   - [Working with UI Sets](#working-with-ui-sets)
   - [Async Operations](#async-operations)
 - [Advanced Features](#advanced-features)
-  - [Delayed UI Presenters](#delayed-ui-presenters)
-  - [UI Toolkit Integration](#ui-toolkit-integration)
+  - [UI Analytics and Performance Tracking](#ui-analytics-and-performance-tracking)
   - [Helper Views](#helper-views)
-- [Package Structure](#package-structure)
-- [Dependencies](#dependencies)
-- [Migration Guide](#migration-guide)
+- [Performance Optimization](#performance-optimization)
+- [Troubleshooting](#troubleshooting)
+- [Examples](#examples)
 - [Contributing](#contributing)
 - [Support](#support)
 - [License](#license)
@@ -36,11 +39,15 @@ A powerful and flexible UI management system for Unity that provides a robust ab
 ## Key Features
 
 - **🎭 UI Presenter Pattern** - Clean separation of UI logic with lifecycle management
+- **🧩 Feature Composition** - Modular feature system for extending presenter behavior
 - **📚 Layer-based Organization** - Organize UI elements by depth layers
 - **🔄 Async Loading** - Load UI assets asynchronously with UniTask support
 - **📦 UI Sets** - Group related UI elements for batch operations
+- **🔀 Multi-Instance Support** - Multiple instances of the same UI type with unique addresses
 - **💾 Memory Management** - Efficient loading/unloading of UI assets
 - **🎯 Type-safe API** - Generic methods for compile-time safety
+- **📊 Analytics & Performance Tracking** - Optional analytics system with dependency injection
+- **🛠️ Editor Tools** - Three powerful editor windows for debugging and monitoring
 - **📱 Responsive Design** - Built-in support for safe areas and screen size adjustments
 - **🔧 Addressables Integration** - Seamless integration with Unity's Addressables system
 - **🎨 UI Toolkit Support** - Compatible with both uGUI and UI Toolkit
@@ -48,7 +55,7 @@ A powerful and flexible UI management system for Unity that provides a robust ab
 ## System Requirements
 
 - **Unity** 6000.0 or higher
-- **Addressables** 1.22.0 or higher
+- **Addressables** 2.6.0 or higher
 - **UniTask** 2.5.10 or higher
 - **TextMeshPro** 3.0.9 or higher
 - **Git** (for installation via Package Manager)
@@ -76,6 +83,62 @@ Add the following line to your project's `Packages/manifest.json`:
 }
 ```
 
+## Package Structure
+
+```
+<root>
+  ├── package.json          # Package manifest with dependencies and metadata
+  ├── README.md             # This documentation file
+  ├── CHANGELOG.md          # Version history and release notes
+  ├── LICENSE.md            # MIT license terms
+  ├── Runtime/              # Core runtime scripts for the UI service
+  │   ├── GameLovers.UiService.asmdef  # Assembly definition for runtime code
+  │   ├── IUiService.cs                # Main service interfaces
+  │   ├── UiService.cs                 # Core service implementation
+  │   ├── UiPresenter.cs               # Base presenter classes
+  │   ├── UiConfigs.cs                 # Configuration ScriptableObjects
+  │   ├── UiInstanceId.cs              # Multi-instance support structure
+  │   ├── UiSetConfig.cs               # UI set configuration
+  │   ├── UiAnalytics.cs               # Analytics and performance tracking
+  │   ├── UiAssetLoader.cs             # Addressables integration
+  │   ├── Features/                    # Composable presenter features
+  │   │   ├── IPresenterFeature.cs     # Feature interface
+  │   │   ├── PresenterFeatureBase.cs  # Base feature implementation
+  │   │   ├── AnimationDelayFeature.cs # Animation-based delays
+  │   │   ├── TimeDelayFeature.cs      # Time-based delays
+  │   │   └── UiToolkitPresenterFeature.cs # UI Toolkit integration
+  │   └── Views/                       # Helper view components
+  │       ├── SafeAreaHelperView.cs
+  │       ├── NonDrawingView.cs
+  │       ├── InteractableTextView.cs
+  │       └── AdjustScreenSizeFitterView.cs
+  ├── Editor/               # Unity Editor extensions and tools
+  │   ├── GameLovers.UiService.Editor.asmdef # Assembly definition for editor code
+  │   ├── UiConfigsEditor.cs           # Custom inspector for UiConfigs with visual hierarchy
+  │   ├── UiPresenterEditor.cs         # Custom inspector for presenters with quick controls
+  │   ├── UiAnalyticsWindow.cs         # Real-time analytics monitoring window
+  │   ├── UiServiceHierarchyWindow.cs  # Live UI hierarchy debugging window
+  │   ├── DefaultUiConfigsEditor.cs    # Default configuration setup
+  │   └── NonDrawingViewEditor.cs      # Custom inspector for NonDrawingView
+  └── Samples~/             # Example implementations
+      ├── README.md                    # Samples documentation
+      ├── BasicUiFlow/                 # Basic presenter usage
+      ├── DataPresenter/               # Data-driven UI examples
+      ├── DelayedPresenter/            # Time and animation delay examples
+      ├── UiToolkit/                   # UI Toolkit integration
+      ├── DelayedUiToolkit/            # Combined features examples
+      └── Analytics/                   # Analytics integration example
+```
+
+## Dependencies
+
+This package requires:
+
+- **[Unity Addressables](https://docs.unity3d.com/Packages/com.unity.addressables@latest)** (v2.6.0+) - For async asset loading
+- **[UniTask](https://github.com/Cysharp/UniTask)** (v2.5.10+) - For efficient async operations
+
+Dependencies are automatically resolved when installing via Unity Package Manager.
+
 ## Quick Start
 
 ### 1. Create UI Configuration
@@ -99,9 +162,14 @@ public class GameInitializer : MonoBehaviour
     
     void Start()
     {
-        // Create and initialize the UI service
+        // Create and initialize the UI service (without analytics)
         _uiService = new UiService();
         _uiService.Init(_uiConfigs);
+        
+        // Or with analytics (opt-in)
+        // var analytics = new UiAnalytics();
+        // _uiService = new UiService(new UiAssetLoader(), analytics);
+        // _uiService.Init(_uiConfigs);
     }
 }
 ```
@@ -178,6 +246,99 @@ public class GameManager : MonoBehaviour
 
 ## Core Concepts
 
+### Editor Windows
+
+The package includes three powerful editor windows for managing, monitoring, and debugging your UI system:
+
+#### 1. Analytics Window
+
+Monitor UI performance metrics and events in real-time during play mode.
+
+**Opening the Window:**
+- Navigate to **Tools → UI Service → Analytics**
+
+**Features:**
+- **Real-time Performance Metrics** - View load, open, and close durations for each UI
+- **Usage Statistics** - Track open/close counts and total lifetime for each presenter
+- **Color-coded Performance** - Visual indicators for slow operations (green/yellow/red)
+- **Timeline Information** - See when UIs were first opened and last closed
+- **Auto-refresh** - Automatically updates metrics while playing
+- **Clear Data** - Reset all collected analytics
+- **Log Summary** - Export performance summary to console
+
+**Usage:**
+1. Open **Tools → UI Service → Analytics**
+2. Enter Play Mode
+3. Use your UI system normally
+4. View metrics updating in real-time
+
+**Performance Thresholds:**
+- **Load Time**: <0.1s (green), <0.5s (yellow), ≥0.5s (red)
+- **Open/Close Time**: <0.05s (green), <0.2s (yellow), ≥0.2s (red)
+
+**Note:** Analytics must be enabled in your UiService initialization to see data:
+```csharp
+var analytics = new UiAnalytics();
+var uiService = new UiService(new UiAssetLoader(), analytics);
+```
+
+#### 2. Hierarchy Window
+
+View and control all active UI presenters in the scene during play mode.
+
+**Opening the Window:**
+- Navigate to **Tools → UI Service → Hierarchy Window**
+
+**Features:**
+- **Live UI Hierarchy** - See all loaded presenters grouped by layer
+- **Status Indicators** - Visual open (🟢) / closed (🔴) status for each UI
+- **Quick Controls** - Open/close any UI with one click
+- **Detailed Inspector** - Expand presenters to see full details
+- **GameObject Navigation** - Select and ping presenters in the hierarchy
+- **Instance Information** - View instance addresses for multi-instance UIs
+- **Batch Operations** - Close all UIs at once
+- **Auto-refresh** - Updates every 0.5 seconds automatically
+
+**Usage:**
+1. Open **Tools → UI Service → Hierarchy Window**
+2. Enter Play Mode
+3. See all active presenters organized by layer
+4. Click on any presenter to expand details
+5. Use quick controls to open/close/destroy UIs
+
+**Keyboard Shortcuts:**
+- Click presenter name to select in hierarchy
+- "Open" button to open closed UIs
+- "Close" button to close open UIs
+
+#### 3. UiConfigs Inspector (Layer Visualizer)
+
+Built-in custom inspector for visualizing your UI configuration and layer organization.
+
+**Features:**
+- **Visual Layer Hierarchy** - See all UIs grouped by layer number in the inspector
+- **Color-coded Layers** - Each layer has a unique color for easy identification
+- **Configuration Overview** - View UiConfigs structure directly in the inspector
+- **Drag & Drop Support** - Reorder UI configs and sets with drag-and-drop
+- **Collapsible Sections** - Expand/collapse layers and sets for better organization
+- **Search & Filter** - Find specific UIs quickly within the inspector
+- **Statistics Panel** - Total UIs, layer distribution, sync vs async loading stats
+- **Synchronous Loading Indicators** - Clearly marks UIs that load synchronously
+- **UI Set Management** - Create, edit, and organize UI sets visually
+
+**Usage:**
+1. Select your `UiConfigs` ScriptableObject in the Project window
+2. View the enhanced inspector with visual layer hierarchy
+3. Browse layer organization and configuration
+4. Use drag-and-drop to reorder items
+5. Review statistics for optimization insights
+
+**Inspector Sections:**
+- **Configuration** - Main UI configuration list with layer visualization
+- **UI Sets** - Manage groups of related UIs
+- **Statistics** - Overview of your UI configuration
+- **Layer Hierarchy** - Visual tree view of all layers and their UIs
+
 ### UI Presenter
 
 The `UiPresenter` is the base class for all UI elements in the system. It provides:
@@ -249,6 +410,198 @@ var profileData = new PlayerProfileData
 await _uiService.OpenUiAsync<PlayerProfilePresenter, PlayerProfileData>(profileData);
 ```
 
+---
+
+### Presenter Features
+
+The UI Service uses a **feature-based composition system** that allows you to extend presenter behavior without inheritance complexity. Features are self-contained components that add specific capabilities to your presenters.
+
+#### Built-in Features
+
+##### 1. TimeDelayFeature
+
+Adds time-based delays to UI opening and closing:
+
+```csharp
+[RequireComponent(typeof(TimeDelayFeature))]
+public class DelayedPopup : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    
+    protected override void OnInitialized()
+    {
+        // Subscribe to delay completion events
+        _delayFeature.OnOpenCompletedEvent += OnDelayComplete;
+    }
+    
+    private void OnDelayComplete()
+    {
+        Debug.Log("Opening delay completed!");
+    }
+    
+    private void OnDestroy()
+    {
+        if (_delayFeature != null)
+            _delayFeature.OnOpenCompletedEvent -= OnDelayComplete;
+    }
+}
+```
+
+**Configuration:**
+- `Open Delay In Seconds` - Time to wait after opening (default: 0.5s)
+- `Close Delay In Seconds` - Time to wait before closing (default: 0.3s)
+
+##### 2. AnimationDelayFeature
+
+Synchronizes UI lifecycle with animation clips:
+
+```csharp
+[RequireComponent(typeof(AnimationDelayFeature))]
+public class AnimatedPopup : UiPresenter
+{
+    [SerializeField] private AnimationDelayFeature _animationFeature;
+    
+    protected override void OnInitialized()
+    {
+        _animationFeature.OnOpenCompletedEvent += OnAnimationComplete;
+    }
+    
+    private void OnAnimationComplete()
+    {
+        Debug.Log("Animation completed!");
+    }
+}
+```
+
+**Configuration:**
+- `Animation Component` - Auto-detected or manually assigned
+- `Intro Animation Clip` - Plays when opening
+- `Outro Animation Clip` - Plays when closing
+
+**Note:** Delays automatically match animation clip lengths!
+
+##### 3. UiToolkitPresenterFeature
+
+Provides UI Toolkit (UI Elements) integration:
+
+```csharp
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class UIToolkitMenu : UiPresenter
+{
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    private Button _playButton;
+    private Label _titleLabel;
+    
+    protected override void OnInitialized()
+    {
+        var root = _toolkitFeature.Root;
+        
+        _playButton = root.Q<Button>("play-button");
+        _titleLabel = root.Q<Label>("title-label");
+        
+        _playButton.clicked += OnPlayClicked;
+    }
+    
+    private void OnPlayClicked()
+    {
+        Close(destroy: false);
+    }
+}
+```
+
+**Configuration:**
+- `Document` - Auto-detects `UIDocument` component
+- Access via `_toolkitFeature.Document` or `_toolkitFeature.Root`
+
+#### Composing Multiple Features
+
+Features can be freely combined:
+
+```csharp
+[RequireComponent(typeof(TimeDelayFeature))]
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class DelayedUiToolkitPresenter : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    protected override void OnInitialized()
+    {
+        // Disable UI until delay completes
+        _toolkitFeature.Root.SetEnabled(false);
+        _delayFeature.OnOpenCompletedEvent += EnableUI;
+    }
+    
+    private void EnableUI()
+    {
+        _toolkitFeature.Root.SetEnabled(true);
+    }
+}
+```
+
+#### Creating Custom Features
+
+Extend `PresenterFeatureBase` to create your own features:
+
+```csharp
+using UnityEngine;
+using GameLovers.UiService;
+
+/// <summary>
+/// Custom feature that adds fade effect
+/// </summary>
+[RequireComponent(typeof(CanvasGroup))]
+public class FadeFeature : PresenterFeatureBase
+{
+    [SerializeField] private CanvasGroup _canvasGroup;
+    [SerializeField] private float _fadeDuration = 0.3f;
+    
+    private void OnValidate()
+    {
+        _canvasGroup = _canvasGroup ?? GetComponent<CanvasGroup>();
+    }
+    
+    public override void OnPresenterOpening()
+    {
+        _canvasGroup.alpha = 0f;
+    }
+    
+    public override void OnPresenterOpened()
+    {
+        StartCoroutine(FadeIn());
+    }
+    
+    private IEnumerator FadeIn()
+    {
+        float elapsed = 0f;
+        while (elapsed < _fadeDuration)
+        {
+            _canvasGroup.alpha = elapsed / _fadeDuration;
+            elapsed += Time.deltaTime;
+            yield return null;
+        }
+        _canvasGroup.alpha = 1f;
+    }
+}
+```
+
+**Available Lifecycle Hooks:**
+- `OnPresenterInitialized(UiPresenter presenter)` - Called once when presenter is initialized
+- `OnPresenterOpening()` - Called before UI is shown
+- `OnPresenterOpened()` - Called after UI is shown
+- `OnPresenterClosing()` - Called before UI is hidden
+- `OnPresenterClosed()` - Called after UI is hidden
+
+**Benefits of Feature Composition:**
+- ✅ **No Inheritance Conflicts** - Mix any features freely
+- ✅ **Self-Contained Logic** - Each feature owns its complete behavior
+- ✅ **Inspector Configuration** - All settings visible and editable
+- ✅ **Reusable** - Use the same feature across multiple presenters
+- ✅ **Scalable** - Add new features without modifying existing code
+
+---
+
 ### UI Layers
 
 UI elements are organized into layers, where higher layer numbers appear on top:
@@ -286,77 +639,101 @@ _uiService.CloseAllUiSet(setId: 2);
 _uiService.UnloadUiSet(setId: 2);
 ```
 
-### UI Configuration
+### Multi-Instance Support
 
-Configure your UI in the `UiConfigs` ScriptableObject:
+The UI Service supports multiple instances of the same UI type using the `UiInstanceId` system. This allows you to have multiple instances of the same presenter active simultaneously, each with a unique instance address.
 
-1. **Type** - The presenter class type
-2. **Prefab Reference** - Addressable reference to the UI prefab
-3. **Layer** - Which layer the UI belongs to
-4. **Load Synchronously** - Whether to load synchronously (use sparingly)
-5. **UI Set ID** - Optional grouping ID
+#### Creating Multi-Instance UIs
 
-## API Documentation
+```csharp
+// Load multiple instances of the same UI type
+var chest1 = await _uiService.LoadUiAsync<ChestRewardPresenter>(
+    instanceAddress: "chest_1");
+var chest2 = await _uiService.LoadUiAsync<ChestRewardPresenter>(
+    instanceAddress: "chest_2");
 
-### Creating UI Presenters
+// Open with data
+await _uiService.OpenUiAsync<ChestRewardPresenter, ChestData>(
+    chestData1, instanceAddress: "chest_1");
+await _uiService.OpenUiAsync<ChestRewardPresenter, ChestData>(
+    chestData2, instanceAddress: "chest_2");
+```
 
-#### Simple Presenter
+#### Working with Instances
 
 ```csharp
-public class NotificationPresenter : UiPresenter
-{
-    [SerializeField] private TextMeshProUGUI _messageText;
-    [SerializeField] private float _displayDuration = 3f;
-    
-    public void SetMessage(string message)
-    {
-        _messageText.text = message;
-    }
-    
-    protected override void OnOpened()
-    {
-        // Auto-close after duration
-        StartCoroutine(AutoClose());
-    }
-    
-    private IEnumerator AutoClose()
-    {
-        yield return new WaitForSeconds(_displayDuration);
-        Close(destroy: false);
-    }
-}
-```
+// Get specific instance
+var chest1 = _uiService.GetUi<ChestRewardPresenter>(instanceAddress: "chest_1");
+
+// Check if specific instance is visible
+bool isVisible = _uiService.IsVisible<ChestRewardPresenter>(
+    instanceAddress: "chest_1");
 
-#### Delayed UI Presenter
+// Close specific instance
+_uiService.CloseUi<ChestRewardPresenter>(
+    instanceAddress: "chest_1", destroy: false);
+
+// Unload specific instance
+_uiService.UnloadUi<ChestRewardPresenter>(instanceAddress: "chest_1");
+```
 
-For UI with opening/closing animations:
+#### Getting All Instances
 
 ```csharp
-public class AnimatedPopup : DelayUiPresenter
+// Get all loaded presenters
+var allInstances = _uiService.GetLoadedPresenters();
+
+foreach (var instance in allInstances)
 {
-    [SerializeField] private Animator _animator;
-    [SerializeField] private float _openDuration = 0.5f;
-    [SerializeField] private float _closeDuration = 0.3f;
-    
-    protected override void ConfigureDelayers()
-    {
-        // Use animation-based delays
-        OpeningDelayer = new AnimationDelayer(_animator, "Open");
-        ClosingDelayer = new AnimationDelayer(_animator, "Close");
-        
-        // Or use time-based delays
-        // OpeningDelayer = new TimeDelayer(_openDuration);
-        // ClosingDelayer = new TimeDelayer(_closeDuration);
-    }
-    
-    protected override void OnOpened()
-    {
-        base.OnOpened();
-        // UI is fully open and animation complete
-    }
+    Debug.Log($"Type: {instance.Type.Name}, Address: {instance.Address}");
 }
+
+// Filter by type
+var chestInstances = allInstances
+    .Where(i => i.Type == typeof(ChestRewardPresenter))
+    .ToList();
 ```
 
+#### Default vs Named Instances
+
+```csharp
+// Default instance (singleton behavior)
+await _uiService.OpenUiAsync<MainMenuPresenter>();
+
+// Named instances (multi-instance)
+await _uiService.OpenUiAsync<DialogPresenter>(
+    instanceAddress: "confirm_purchase");
+await _uiService.OpenUiAsync<DialogPresenter>(
+    instanceAddress: "confirm_exit");
+```
+
+**Best Practices:**
+- Use default instances (no address) for singleton UIs (HUD, main menu, etc.)
+- Use named instances for UIs that can appear multiple times (dialogs, notifications, rewards)
+- Always specify instance address when working with multi-instance UIs to avoid ambiguity
+
+**Note:** If you call `GetUi<T>()` without specifying an instance address when multiple instances exist, a warning will be logged and the first found instance will be returned.
+
+---
+
+### UI Configuration
+
+Configure your UI in the `UiConfigs` ScriptableObject:
+
+1. **Type** - The presenter class type
+2. **Addressable Address** - Addressable reference key to the UI prefab
+3. **Layer** - Which layer the UI belongs to (higher = closer to camera)
+4. **Load Synchronously** - Whether to load synchronously (use sparingly for critical UIs)
+5. **UI Set ID** - Optional grouping ID for batch operations
+
+**Creating a UiConfigs Asset:**
+1. Right-click in Project View
+2. Navigate to `Create` → `ScriptableObjects` → `Configs` → `UiConfigs`
+3. Configure your UI presenters in the created asset
+4. Assign the asset to your UI service initialization
+
+## API Documentation
+
 ### Managing UI Lifecycle
 
 #### Loading and Unloading
@@ -368,14 +745,20 @@ var ui = await _uiService.LoadUiAsync<InventoryPresenter>();
 // Load and immediately open
 var ui = await _uiService.LoadUiAsync<InventoryPresenter>(openAfter: true);
 
+// Load with specific instance address (multi-instance)
+var ui = await _uiService.LoadUiAsync<NotificationPresenter>(
+    instanceAddress: "reward_notification", 
+    openAfter: false);
+
 // Check if loaded
-if (_uiService.LoadedPresenters.ContainsKey(typeof(InventoryPresenter)))
-{
-    // UI is loaded in memory
-}
+var loadedPresenters = _uiService.GetLoadedPresenters();
+bool isLoaded = loadedPresenters.Any(p => p.Type == typeof(InventoryPresenter));
 
 // Unload from memory
 _uiService.UnloadUi<InventoryPresenter>();
+
+// Unload specific instance
+_uiService.UnloadUi<NotificationPresenter>(instanceAddress: "reward_notification");
 ```
 
 #### Opening and Closing
@@ -446,69 +829,222 @@ catch (OperationCanceledException)
 
 ## Advanced Features
 
-### Delayed UI Presenters
+### UI Analytics and Performance Tracking
+
+The UI Service includes an optional analytics system for tracking UI events and performance metrics. Analytics is **opt-in** via dependency injection.
 
-The `DelayUiPresenter` class provides built-in support for opening/closing animations:
+#### Enabling Analytics
 
 ```csharp
-public class SlideInPanel : DelayUiPresenter
+using GameLovers.UiService;
+using UnityEngine;
+
+public class GameInitializer : MonoBehaviour
 {
-    [SerializeField] private RectTransform _panel;
-    [SerializeField] private float _slideDuration = 0.5f;
+    [SerializeField] private UiConfigs _uiConfigs;
     
-    protected override void ConfigureDelayers()
+    void Start()
     {
-        OpeningDelayer = new TimeDelayer(_slideDuration);
-        ClosingDelayer = new TimeDelayer(_slideDuration);
+        // Create analytics instance
+        var analytics = new UiAnalytics();
+        
+        // Inject analytics into UI service
+        var uiService = new UiService(new UiAssetLoader(), analytics);
+        uiService.Init(_uiConfigs);
+        
+        // Analytics is now tracking all UI events
     }
+}
+```
+
+#### Running Without Analytics
+
+By default, the UI Service runs without analytics overhead:
+
+```csharp
+// No analytics - uses NullAnalytics internally (zero overhead)
+var uiService = new UiService();
+uiService.Init(_uiConfigs);
+
+// Or explicitly without analytics
+var uiService = new UiService(new UiAssetLoader(), null);
+```
+
+#### What Gets Tracked
+
+When analytics is enabled, the system automatically tracks:
+
+- **UI Loading** - Time to load UI from Addressables
+- **UI Opening** - Time to complete opening animations
+- **UI Closing** - Time to complete closing animations
+- **UI Lifecycle** - Total lifetime from first open to final close
+- **Open/Close Counts** - How many times each UI was opened/closed
+- **Timestamps** - When UI was first opened and last closed
+
+#### Accessing Performance Metrics
+
+```csharp
+public class PerformanceMonitor : MonoBehaviour
+{
+    private IUiService _uiService;
     
-    protected override void OnPreOpen()
+    void LogPerformance()
     {
-        // Position panel off-screen
-        _panel.anchoredPosition = new Vector2(-1000, 0);
+        var analytics = _uiService.Analytics;
+        
+        // Get all metrics
+        foreach (var kvp in analytics.PerformanceMetrics)
+        {
+            var metrics = kvp.Value;
+            Debug.Log($"{metrics.UiName}:");
+            Debug.Log($"  Load Time: {metrics.LoadDuration:F3}s");
+            Debug.Log($"  Open Time: {metrics.OpenDuration:F3}s");
+            Debug.Log($"  Close Time: {metrics.CloseDuration:F3}s");
+            Debug.Log($"  Opened {metrics.OpenCount} times");
+            Debug.Log($"  Total Lifetime: {metrics.TotalLifetime:F1}s");
+        }
+        
+        // Get specific UI metrics
+        var shopMetrics = analytics.GetMetrics(typeof(ShopPresenter));
+        if (shopMetrics.OpenCount > 0)
+        {
+            Debug.Log($"Shop was opened {shopMetrics.OpenCount} times");
+        }
+        
+        // Print summary to console
+        analytics.LogPerformanceSummary();
     }
+}
+```
+
+#### Subscribing to Analytics Events
+
+```csharp
+public class AnalyticsListener : MonoBehaviour
+{
+    private IUiService _uiService;
     
-    protected override void OnOpening()
+    void Start()
     {
-        // Animate panel sliding in
-        _panel.DOAnchorPosX(0, _slideDuration);
+        var analytics = _uiService.Analytics;
+        
+        // Subscribe to Unity Events
+        analytics.OnUiOpened.AddListener(OnUiOpened);
+        analytics.OnUiClosed.AddListener(OnUiClosed);
+        analytics.OnPerformanceMetricsUpdated.AddListener(OnMetricsUpdated);
+    }
+    
+    private void OnUiOpened(UiEventData data)
+    {
+        Debug.Log($"UI Opened: {data.UiName} on layer {data.Layer}");
+        // Send to your analytics backend
+        SendToBackend("ui_opened", data.UiName);
+    }
+    
+    private void OnUiClosed(UiEventData data)
+    {
+        Debug.Log($"UI Closed: {data.UiName} (destroyed: {data.WasDestroyed})");
     }
     
-    protected override void OnClosing()
+    private void OnMetricsUpdated(UiPerformanceMetrics metrics)
     {
-        // Animate panel sliding out
-        _panel.DOAnchorPosX(-1000, _slideDuration);
+        // Track performance issues
+        if (metrics.LoadDuration > 1.0f)
+        {
+            Debug.LogWarning($"{metrics.UiName} took {metrics.LoadDuration:F2}s to load!");
+        }
     }
 }
 ```
 
-### UI Toolkit Integration
+#### Custom Analytics Integration
 
-For UI Toolkit (UI Elements) support:
+Implement `IUiAnalyticsCallback` for custom analytics backends:
 
 ```csharp
-public class UIToolkitMenu : UiToolkitPresenter
+public class CustomAnalytics : IUiAnalyticsCallback
 {
-    [SerializeField] private UIDocument _document;
+    public void OnUiLoaded(UiEventData data)
+    {
+        // Send to Firebase, Unity Analytics, or custom backend
+        FirebaseAnalytics.LogEvent("ui_loaded", new Parameter("ui_name", data.UiName));
+    }
     
-    private Button _playButton;
-    private Label _titleLabel;
+    public void OnUiOpened(UiEventData data)
+    {
+        MyAnalyticsService.Track("ui_opened", new { 
+            name = data.UiName, 
+            layer = data.Layer,
+            timestamp = data.Timestamp 
+        });
+    }
     
-    protected override void OnInitialized()
+    public void OnUiClosed(UiEventData data)
     {
-        var root = _document.rootVisualElement;
-        
-        _playButton = root.Q<Button>("play-button");
-        _titleLabel = root.Q<Label>("title-label");
-        
-        _playButton.clicked += OnPlayClicked;
+        MyAnalyticsService.Track("ui_closed", new { 
+            name = data.UiName,
+            destroyed = data.WasDestroyed
+        });
     }
     
-    private void OnPlayClicked()
+    public void OnUiUnloaded(UiEventData data)
     {
-        Close(destroy: false);
+        // Track memory management
+    }
+    
+    public void OnPerformanceMetricsUpdated(UiPerformanceMetrics metrics)
+    {
+        // Send performance data
+        if (metrics.LoadDuration > 0.5f)
+        {
+            MyAnalyticsService.TrackPerformance("slow_ui_load", metrics.UiName, metrics.LoadDuration);
+        }
     }
 }
+
+// Register callback
+void Start()
+{
+    var analytics = new UiAnalytics();
+    analytics.SetCallback(new CustomAnalytics());
+    
+    var uiService = new UiService(new UiAssetLoader(), analytics);
+    uiService.Init(_uiConfigs);
+}
+```
+
+#### Creating Custom Analytics Implementations
+
+You can create custom analytics implementations for special use cases:
+
+```csharp
+public class FileLoggingAnalytics : IUiAnalytics
+{
+    private readonly UiAnalytics _baseAnalytics = new UiAnalytics();
+    private readonly StreamWriter _logFile;
+    
+    public FileLoggingAnalytics(string logPath)
+    {
+        _logFile = new StreamWriter(logPath, append: true);
+    }
+    
+    public void TrackOpenComplete(Type uiType, int layer)
+    {
+        // Log to file
+        _logFile.WriteLine($"{DateTime.Now:HH:mm:ss} - Opened: {uiType.Name}");
+        _logFile.Flush();
+        
+        // Also track normally
+        _baseAnalytics.TrackOpenComplete(uiType, layer);
+    }
+    
+    // Implement other IUiAnalytics methods...
+    // Delegate to _baseAnalytics for standard tracking
+}
+
+// Usage
+var analytics = new FileLoggingAnalytics("ui_events.log");
+var uiService = new UiService(new UiAssetLoader(), analytics);
 ```
 
 ### Helper Views
@@ -560,36 +1096,461 @@ var interactableText = gameObject.AddComponent<InteractableTextView>();
 // Supports <link> tags in TextMeshPro for clickable URLs
 ```
 
-## Package Structure
+## Performance Optimization
+
+### Memory Management Best Practices
 
+#### When to Load vs. Preload UI
+
+**Load on Demand** (Lazy Loading):
+```csharp
+// Best for: Infrequently used UI, large asset sizes
+await _uiService.OpenUiAsync<SettingsMenu>();
+// Loads and opens in one call - UI loads when needed
 ```
-<root>
-  ├── package.json          # Package manifest with dependencies and metadata
-  ├── README.md             # This documentation file
-  ├── CHANGELOG.md          # Version history and release notes
-  ├── LICENSE.md            # MIT license terms
-  ├── Runtime/              # Core runtime scripts for the UI service
-  │   ├── *.asmdef          # Assembly definition for runtime code
-  │   ├── Core Services     # Main UI service implementation and interfaces
-  │   ├── Presenters        # Base classes for UI presenters and UI Toolkit support
-  │   ├── Configuration     # ScriptableObject configs for UI setup
-  │   ├── Asset Loading     # Addressables integration and loading utilities
-  │   ├── Delayers/         # Animation and time-based delay implementations
-  │   └── Views/            # Helper components for responsive and optimized UI
-  └── Editor/               # Unity Editor extensions and custom inspectors
-      ├── *.asmdef          # Assembly definition for editor code
-      ├── Config Editors    # Custom inspectors for UI configuration assets
-      └── View Editors      # Custom editors for specialized UI components
+
+**Preload** (Eager Loading):
+```csharp
+// Best for: Frequently used UI, critical path, avoid loading hitches
+await _uiService.LoadUiAsync<GameHud>();
+// Loads into memory but keeps hidden - ready to open instantly
 ```
 
-## Dependencies
+**When to Use Each Strategy**:
 
-This package requires:
+| Strategy | Use For | Pros | Cons |
+|----------|---------|------|------|
+| **On Demand** | Settings, shops, rare popups | Lower initial memory | Loading hitch when opened |
+| **Preload** | HUD, frequent dialogs | Instant display | Higher memory usage |
+| **Preload Sets** | Level-specific UI groups | Batch loading efficiency | Memory overhead |
 
-- **[Unity Addressables](https://docs.unity3d.com/Packages/com.unity.addressables@latest)** (v2.6.0+) - For async asset loading
-- **[UniTask](https://github.com/Cysharp/UniTask)** (v2.5.10+) - For efficient async operations
+#### Unloading UI from Memory
 
-Dependencies are automatically resolved when installing via Unity Package Manager.
+```csharp
+// Close but keep in memory (fast to reopen)
+_uiService.CloseUi<Shop>(destroy: false);
+
+// Close and unload from memory (free resources)
+_uiService.CloseUi<Shop>(destroy: true);
+// Or explicitly:
+_uiService.UnloadUi<Shop>();
+```
+
+**When to Destroy**:
+- ✅ Large UI assets (>5MB)
+- ✅ Level-specific UI when changing levels
+- ✅ One-time tutorial/onboarding screens
+- ❌ Frequently reopened UI (Settings, Pause Menu)
+- ❌ Small, lightweight presenters
+
+#### UI Sets for Efficient Batch Management
+
+```csharp
+// Define in UiConfigs: SetId 1 = Main Menu Set
+// Contains: MainMenu, Background, Logo, Buttons
+
+// Load entire menu system at once
+var tasks = _uiService.LoadUiSetAsync(setId: 1);
+await UniTask.WhenAll(tasks);
+
+// When done with menu (e.g., entering gameplay):
+_uiService.CloseAllUiSet(setId: 1);
+_uiService.UnloadUiSet(setId: 1); // Free all menu memory
+```
+
+**Recommended Set Organization**:
+- Set 0: Core/Persistent UI (always loaded)
+- Set 1-10: Scene-specific UI (load per scene)
+- Set 11-20: Feature-specific UI (shop, inventory, etc.)
+
+---
+
+### Performance Monitoring
+
+#### Detecting Memory Issues
+
+```csharp
+// Check what's currently loaded
+Debug.Log($"Loaded presenters: {_uiService.LoadedPresenters.Count}");
+foreach (var kvp in _uiService.LoadedPresenters)
+{
+    Debug.Log($"  - {kvp.Key.Name}");
+}
+
+// Monitor visible UI
+Debug.Log($"Visible presenters: {_uiService.VisiblePresenters.Count}");
+```
+
+#### Profiling UI Operations
+
+Use Unity Profiler to monitor:
+1. **Memory.Allocations** - Watch for GC spikes during `OpenUiAsync`
+2. **Memory.Total** - Track memory after `LoadUiAsync` / `UnloadUi`
+3. **Loading.AsyncLoad** - Identify slow-loading UI assets
+
+**Red Flags**:
+- More than 10 presenters loaded simultaneously
+- Loading same UI multiple times per second
+- Memory not decreasing after `UnloadUi`
+
+---
+
+### Optimization Tips
+
+#### 1. Avoid Opening Same UI Repeatedly
+
+```csharp
+// ❌ BAD - Opens new instance every frame
+void Update()
+{
+    if (Input.GetKeyDown(KeyCode.Escape))
+        _uiService.OpenUiAsync<PauseMenu>().Forget();
+}
+
+// ✅ GOOD - Check if already visible
+void Update()
+{
+    if (Input.GetKeyDown(KeyCode.Escape) && !_uiService.IsVisible<PauseMenu>())
+        _uiService.OpenUiAsync<PauseMenu>().Forget();
+}
+```
+
+#### 2. Use Parallel Loading for Multiple UI
+
+```csharp
+// ❌ SLOW - Sequential loading (3 seconds total if each takes 1s)
+await _uiService.OpenUiAsync<Hud>();
+await _uiService.OpenUiAsync<Minimap>();
+await _uiService.OpenUiAsync<Chat>();
+
+// ✅ FAST - Parallel loading (1 second total)
+await UniTask.WhenAll(
+    _uiService.OpenUiAsync<Hud>(),
+    _uiService.OpenUiAsync<Minimap>(),
+    _uiService.OpenUiAsync<Chat>()
+);
+```
+
+#### 3. Preload Critical UI During Loading Screen
+
+```csharp
+public async UniTask LoadLevel()
+{
+    // Show loading screen
+    await _uiService.OpenUiAsync<LoadingScreen>();
+    
+    // Preload level UI in parallel with level load
+    var uiTask = UniTask.WhenAll(
+        _uiService.LoadUiAsync<GameHud>(),
+        _uiService.LoadUiAsync<PauseMenu>(),
+        _uiService.LoadUiAsync<GameOverScreen>()
+    );
+    var levelTask = SceneManager.LoadSceneAsync("GameLevel").ToUniTask();
+    
+    await UniTask.WhenAll(uiTask, levelTask);
+    
+    // Hide loading screen
+    _uiService.CloseUi<LoadingScreen>();
+}
+```
+
+#### 4. Clean Up When Switching Scenes
+
+```csharp
+async void OnLevelComplete()
+{
+    // Close all gameplay UI
+    _uiService.CloseAllUi(layer: 1); // Gameplay layer
+    
+    // Unload gameplay UI set
+    _uiService.UnloadUiSet(setId: 2);
+    
+    // Load main menu
+    await _uiService.OpenUiAsync<LevelCompleteScreen>();
+}
+```
+
+#### 5. Optimize Feature Usage
+
+**Animation Performance**:
+```csharp
+// ✅ GOOD - Use TimeDelayFeature for simple fades (lighter)
+[RequireComponent(typeof(TimeDelayFeature))]
+public class SimpleFadePopup : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    // Configure 0.3s delays in inspector
+}
+
+// ⚠️ HEAVIER - AnimationDelayFeature for complex animations
+[RequireComponent(typeof(AnimationDelayFeature))]
+public class ComplexAnimatedPopup : UiPresenter
+{
+    [SerializeField] private AnimationDelayFeature _animationFeature;
+    // Only use if you need complex animation sequences
+}
+```
+
+**Feature Best Practices**:
+- Keep open/close delays under 0.5 seconds for better user experience
+- Use `TimeDelayFeature` for simple timed delays (more performant)
+- Use `AnimationDelayFeature` only when synchronized with actual animations
+- Disable `Animation`/`Animator` components when UI is closed
+- Avoid adding unnecessary features - each feature adds minimal overhead but it adds up
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+#### Issue: Data Not Showing in UiPresenter<TData>
+
+**Symptoms**: UI opens but data fields are empty/default
+
+**Possible Causes & Solutions**:
+
+1. **Not Using Generic Open Method**
+   ```csharp
+   // ❌ WRONG - Data not passed
+   await _uiService.OpenUiAsync<PlayerProfile>();
+   
+   // ✅ CORRECT - Use generic overload
+   var data = new PlayerData { Name = "Hero", Level = 10 };
+   await _uiService.OpenUiAsync<PlayerProfile, PlayerData>(data);
+   ```
+
+2. **OnSetData Not Implemented**
+   ```csharp
+   public class PlayerProfile : UiPresenter<PlayerData>
+   {
+       // ❌ MISSING - Override OnSetData
+       
+       // ✅ CORRECT
+       protected override void OnSetData()
+       {
+           nameText.text = Data.Name;
+           levelText.text = Data.Level.ToString();
+       }
+   }
+   ```
+
+3. **Wrong Base Class**
+   ```csharp
+   // ❌ WRONG - Missing <T> generic
+   public class PlayerProfile : UiPresenter
+   
+   // ✅ CORRECT
+   public class PlayerProfile : UiPresenter<PlayerData>
+   ```
+
+---
+
+#### Issue: Animations Not Playing
+
+**Symptoms**: UI with `AnimationDelayFeature` opens/closes instantly without animation
+
+**Possible Causes & Solutions**:
+
+1. **Feature Not Added**
+   ```csharp
+   // ❌ MISSING - Feature component not attached
+   public class AnimatedPopup : UiPresenter
+   {
+       // Missing [RequireComponent(typeof(AnimationDelayFeature))]
+   }
+   
+   // ✅ CORRECT
+   [RequireComponent(typeof(AnimationDelayFeature))]
+   public class AnimatedPopup : UiPresenter
+   {
+       [SerializeField] private AnimationDelayFeature _animationFeature;
+   }
+   ```
+
+2. **Animation Clips Not Assigned**
+   ```csharp
+   // Check in Inspector:
+   // - Animation Component is assigned
+   // - Intro Animation Clip is assigned
+   // - Outro Animation Clip is assigned
+   
+   // Or use TimeDelayFeature instead:
+   [RequireComponent(typeof(TimeDelayFeature))]
+   public class SimpleDelayedPopup : UiPresenter
+   {
+       [SerializeField] private TimeDelayFeature _delayFeature;
+       // Configure delays in inspector
+   }
+   ```
+
+3. **Animation Component Missing**
+   ```csharp
+   // AnimationDelayFeature requires an Animation component
+   // Add Animation component to the GameObject
+   // Or use Animator with AnimationClips
+   ```
+
+---
+
+#### Issue: "UiConfig was not added to the service" Error
+
+**Error**: `KeyNotFoundException: The UiConfig of type X was not added to the service`
+
+**Cause**: UI type not registered in `UiConfigs` asset
+
+**Solution**:
+1. Open your `UiConfigs` ScriptableObject asset
+2. Add a new entry for your presenter type
+3. Set the addressable reference to your UI prefab
+4. Set the layer number
+5. Save the asset
+
+```csharp
+// In UiConfigs inspector:
+// Type: MyNewPresenter
+// Addressable: Assets/UI/MyNewPresenter.prefab
+// Layer: 2
+```
+
+---
+
+#### Issue: UI Flickers or Appears Briefly Before Opening
+
+**Cause**: UI GameObject is active during initialization
+
+**Solution**: UiService automatically handles this, but if creating UI manually:
+```csharp
+// Ensure prefab's root GameObject is DISABLED in the prefab
+// The service will enable it when ready
+```
+
+---
+
+#### Issue: Cancellation Not Working
+
+**Symptoms**: `CancellationToken` doesn't stop UI loading
+
+**Possible Causes**:
+
+1. **Token Not Passed Through**
+   ```csharp
+   // ❌ WRONG - Token not used
+   await _uiService.OpenUiAsync<Shop>();
+   
+   // ✅ CORRECT - Pass token
+   var cts = new CancellationTokenSource();
+   await _uiService.OpenUiAsync<Shop>(cancellationToken: cts.Token);
+   ```
+
+2. **Cancelling After Load Complete**
+   ```csharp
+   // Can only cancel during async load, not after
+   var task = _uiService.OpenUiAsync<Shop>(ct);
+   await task; // Already complete
+   cts.Cancel(); // Too late - no effect
+   ```
+
+### Still Having Issues?
+
+1. **Check Unity Console** - Look for warnings/errors from UiService
+2. **Verify Dependencies** - Ensure UniTask and Addressables are installed
+3. **Review CHANGELOG** - Check if recent version introduced breaking changes
+4. **Search GitHub Issues** - Your issue may already be reported
+5. **Create New Issue** - [Report bug](https://github.com/CoderGamester/com.gamelovers.uiservice/issues) with:
+   - Unity version
+   - Package version
+   - Code sample
+   - Error logs
+   - Steps to reproduce
+
+---
+
+## Examples
+
+The package includes comprehensive examples demonstrating all features and patterns. Examples are located in the `Samples~` folder.
+
+### Importing Samples
+
+1. Open Unity Package Manager (`Window` → `Package Manager`)
+2. Select "UI Service" package
+3. Navigate to the "Samples" tab
+4. Click "Import" next to the sample you want
+
+### Available Samples
+
+#### 1. **BasicUiFlow**
+Demonstrates basic presenter lifecycle and simple button interactions.
+
+**What you'll learn:**
+- Creating basic UI presenters
+- Opening and closing UI
+- Handling button clicks
+- Lifecycle methods (`OnInitialized`, `OnOpened`, `OnClosed`)
+
+#### 2. **DataPresenter**
+Shows how to create data-driven UI with `UiPresenter<T>`.
+
+**What you'll learn:**
+- Using `UiPresenter<TData>` generic base class
+- Setting presenter data with `OnSetData()`
+- Passing data when opening UI
+- Data-driven UI updates
+
+#### 3. **DelayedPresenter**
+Examples of time-based and animation-based delays.
+
+**What you'll learn:**
+- Using `TimeDelayFeature` for timed delays
+- Using `AnimationDelayFeature` for animation synchronization
+- Subscribing to delay completion events
+- Configuring delays in the Inspector
+
+#### 4. **UiToolkit**
+UI Toolkit (UI Elements) integration example.
+
+**What you'll learn:**
+- Using `UiToolkitPresenterFeature`
+- Querying VisualElements
+- Binding UI Toolkit events
+- Working with UXML layouts
+
+#### 5. **DelayedUiToolkit**
+Advanced example combining multiple features.
+
+**What you'll learn:**
+- Composing multiple features together
+- Combining delays with UI Toolkit
+- Coordinating feature interactions
+- Using data with multiple features
+
+#### 6. **Analytics**
+Analytics integration and custom callbacks.
+
+**What you'll learn:**
+- Enabling analytics tracking
+- Implementing `IUiAnalyticsCallback`
+- Tracking UI events
+- Integrating with custom analytics backends
+
+### Sample Documentation
+
+Each sample folder includes:
+- **Source code** with detailed comments
+- **Example scenes** ready to run
+- **Prefabs** demonstrating proper setup
+- **UXML files** for UI Toolkit examples
+
+For detailed sample documentation, see `Samples~/README.md` after importing.
+
+### Running Samples
+
+1. Import the desired sample
+2. Open the example scene from `Samples/UiService/<SampleName>/`
+3. Enter Play Mode
+4. Interact with the UI to see features in action
+
+**Note:** All samples use the pure feature composition pattern introduced in v1.0.0.
+
+---
 
 ## Contributing
 
@@ -651,6 +1612,50 @@ This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md
 
 ---
 
+## Migration Guide
+
+### Upgrading from v0.x to v1.0.0
+
+**Breaking Changes:**
+
+1. **DelayUiPresenter Removed**
+   - **Old (v0.x):**
+     ```csharp
+     public class MyPresenter : DelayUiPresenter
+     {
+         protected override void ConfigureDelayers()
+         {
+             OpeningDelayer = new TimeDelayer(0.5f);
+         }
+     }
+     ```
+   - **New (v1.0.0):**
+     ```csharp
+     [RequireComponent(typeof(TimeDelayFeature))]
+     public class MyPresenter : UiPresenter
+     {
+         [SerializeField] private TimeDelayFeature _delayFeature;
+         // Configure delays in Inspector
+     }
+     ```
+
+2. **LoadedPresenters Property Changed to Method**
+   - **Old:** `var loaded = _uiService.LoadedPresenters;`
+   - **New:** `var loaded = _uiService.GetLoadedPresenters();`
+
+3. **Multi-Instance API Changes**
+   - All methods now accept optional `instanceAddress` parameter
+   - Use `GetLoadedPresenters()` instead of accessing dictionary directly
+
+**Non-Breaking Additions:**
+- Feature composition system is additive (existing presenters still work)
+- Analytics is opt-in (no changes needed if not using)
+- Multi-instance support is backwards compatible (default instances work as before)
+
+For detailed changes, see [CHANGELOG.md](CHANGELOG.md).
+
+---
+
 **Made with ❤️ for the Unity community**
 
 *If this package helps your project, please consider giving it a ⭐ on GitHub!*
diff --git a/Runtime/AssemblyInfo.cs b/Runtime/AssemblyInfo.cs
new file mode 100644
index 0000000..bcbec52
--- /dev/null
+++ b/Runtime/AssemblyInfo.cs
@@ -0,0 +1,12 @@
+using System.Runtime.CompilerServices;
+
+// Assembly information for GameLovers.UiService
+// 
+// This file exposes internal members of the runtime assembly to other assemblies within this package.
+// Use the [InternalsVisibleTo] attribute to grant access to internal APIs without making them public.
+
+// Makes internal members visible to the Editor assembly.
+// This allows editor tools (like UiAnalyticsWindow) to access internal APIs such as UiService.CurrentAnalytics
+// without making them public to end users.
+[assembly: InternalsVisibleTo("GameLovers.UiService.Editor")]
+
diff --git a/Runtime/AssemblyInfo.cs.meta b/Runtime/AssemblyInfo.cs.meta
new file mode 100644
index 0000000..a0dc56d
--- /dev/null
+++ b/Runtime/AssemblyInfo.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d
\ No newline at end of file
diff --git a/Runtime/DelayUiPresenter.cs b/Runtime/DelayUiPresenter.cs
deleted file mode 100644
index 7b15d00..0000000
--- a/Runtime/DelayUiPresenter.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-using UnityEngine;
-
-namespace GameLovers.UiService
-{
-	/// <summary>
-	/// Abstract base class for UI presenters that delay their opening and closing.
-	/// </summary>
-	[RequireComponent(typeof(PresenterDelayerBase))]
-	public abstract class DelayUiPresenter : UiPresenter
-	{
-		[SerializeField] private PresenterDelayerBase _delayer;
-
-		private void OnValidate()
-		{
-			_delayer = _delayer != null ? _delayer : GetComponent<PresenterDelayerBase>();
-
-			OnEditorValidate();
-		}
-
-		/// <inheritdoc />
-		protected override void OnOpened()
-		{
-			_ = _delayer.OpenWithDelay(OnOpenedCompleted);
-		}
-
-		/// <inheritdoc />
-		protected override void OnClosed()
-		{
-			_ = _delayer.CloseWithDelay(OnClosedCompleted);
-		}
-
-		/// <summary>
-		/// Called only in the Editor. Called in the end of this object MonoBehaviour's OnValidate() -> <see cref="OnValidate"/>
-		/// </summary>
-		protected virtual void OnEditorValidate() { }
-
-		/// <summary>
-		/// Called when the presenter's opening delay is completed.
-		/// </summary>
-		protected virtual void OnOpenedCompleted() { }
-
-		/// <summary>
-		/// Called when the presenter's closing delay is completed.
-		/// </summary>
-		protected virtual void OnClosedCompleted() { }
-
-		internal override void InternalClose(bool destroy)
-		{
-			// Override the behaviour to not allow the presenter to be disabled until delay is done.
-			// Not pretty inherithance with it's dependency but it works
-			if (destroy)
-			{
-				base.InternalClose(true);
-			}
-			else
-			{
-				OnClosed();
-			}
-		}
-	}
-
-	/// <inheritdoc cref="DelayUiPresenter"/>
-	/// <remarks>
-	/// Extends the presenter behaviour to hold data of type <typeparamref name="T"/>
-	/// </remarks>
-	/// <typeparam name="T">The type of data held by the presenter.</typeparam>
-	[RequireComponent(typeof(PresenterDelayerBase))]
-	public abstract class DelayUiPresenterData<T> : UiPresenter, IUiPresenterData where T : struct
-	{
-		[SerializeField] private PresenterDelayerBase _delayer;
-
-		private void OnValidate()
-		{
-			_delayer = _delayer ?? GetComponent<PresenterDelayerBase>();
-
-			OnEditorValidate();
-		}
-
-		/// <inheritdoc />
-		protected override void OnOpened()
-		{
-			_ = _delayer.OpenWithDelay(OnOpenedCompleted);
-		}
-
-		/// <inheritdoc />
-		protected override void OnClosed()
-		{
-			_ = _delayer.CloseWithDelay(OnClosedCompleted);
-		}
-
-		/// <summary>
-		/// Called only in the Editor. Called in the end of this object MonoBehaviour's OnValidate() -> <see cref="OnValidate"/>
-		/// </summary>
-		protected virtual void OnEditorValidate() { }
-
-		/// <summary>
-		/// Called when the presenter's opening delay is completed.
-		/// </summary>
-		protected virtual void OnOpenedCompleted() { }
-
-		/// <summary>
-		/// Called when the presenter's closing delay is completed.
-		/// </summary>
-		protected virtual void OnClosedCompleted() { }
-
-		internal override void InternalClose(bool destroy)
-		{
-			// Override the behaviour to not allow the presenter to be disabled until delay is done.
-			// Not pretty inherithance with it's dependency but it works
-			if (destroy)
-			{
-				base.InternalClose(true);
-			}
-			else
-			{
-				OnClosed();
-			}
-		}
-	}
-}
diff --git a/Runtime/DelayUiPresenter.cs.meta b/Runtime/DelayUiPresenter.cs.meta
deleted file mode 100644
index 72e585a..0000000
--- a/Runtime/DelayUiPresenter.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 6dae104c93d028140ab29da9266d90a6
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Runtime/Delayers/AnimationDelayer.cs b/Runtime/Delayers/AnimationDelayer.cs
deleted file mode 100644
index 88dbb3e..0000000
--- a/Runtime/Delayers/AnimationDelayer.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using UnityEngine;
-
-// ReSharper disable CheckNamespace
-
-namespace GameLovers.UiService
-{
-	/// <inheritdoc />
-	/// <remarks>
-	/// Allows this Presenter to have an intro and outro animation when opened and closed to provide feedback and joy for players.
-	/// </remarks>
-	[RequireComponent(typeof(Animation))]
-	public class AnimationDelayer : PresenterDelayerBase
-	{
-		[SerializeField] protected Animation _animation;
-		[SerializeField] protected AnimationClip _introAnimationClip;
-		[SerializeField] protected AnimationClip _outroAnimationClip;
-
-		/// <inheritdoc />
-		public override float OpenDelayInSeconds => _introAnimationClip.length * 1000;
-
-		/// <inheritdoc />
-		public override float CloseDelayInSeconds => _outroAnimationClip.length * 1000;
-
-		private void OnValidate()
-		{ 
-			_animation = _animation != null ? _animation : GetComponent<Animation>();
-		}
-
-		protected override void OnOpenStarted()
-		{
-			_animation.clip = _introAnimationClip;
-			_animation.Play();
-		}
-
-		protected override void OnCloseStarted()
-		{
-			_animation.clip = _outroAnimationClip;
-			_animation.Play();
-		}
-	}
-}
-	
diff --git a/Runtime/Delayers/AnimationDelayer.cs.meta b/Runtime/Delayers/AnimationDelayer.cs.meta
deleted file mode 100644
index 4a489ce..0000000
--- a/Runtime/Delayers/AnimationDelayer.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 739b63b617eca498f8eefa6fb150bd57
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Runtime/Delayers/PresenterDelayerBase.cs b/Runtime/Delayers/PresenterDelayerBase.cs
deleted file mode 100644
index 3b84c2b..0000000
--- a/Runtime/Delayers/PresenterDelayerBase.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using UnityEngine;
-
-namespace GameLovers.UiService
-{
-	/// <summary>
-	/// Contract for presenter delayers, which handle delays for opening and closing presenters.
-	/// </summary>
-	public interface IPresenterDelayer
-	{
-		/// <summary>
-		/// Gets the delay in seconds before opening the presenter.
-		/// </summary>
-		float OpenDelayInSeconds { get; }
-
-		/// <summary>
-		/// Gets the delay in seconds before closing the presenter.
-		/// </summary>
-		float CloseDelayInSeconds { get; }
-
-		/// <summary>
-		/// Gets the Task of the current's delay process
-		/// </summary>
-		Task CurrentDelayTask { get; }
-	}
-
-	/// <inheritdoc />
-	public abstract class PresenterDelayerBase : MonoBehaviour, IPresenterDelayer
-	{
-		/// <inheritdoc />
-		public abstract float OpenDelayInSeconds { get; }
-		/// <inheritdoc />
-		public abstract float CloseDelayInSeconds { get; }
-		/// <inheritdoc />
-		public Task CurrentDelayTask { get; protected set; }
-
-		/// <summary>
-		/// Called when the presenter's opening delay starts.
-		/// </summary>
-		protected virtual void OnOpenStarted() { }
-
-		/// <summary>
-		/// Called when the presenter's closing delay starts.
-		/// </summary>
-		protected virtual void OnCloseStarted() { }
-
-		internal async Task OpenWithDelay(Action onOpenedCompleted)
-		{
-			OnOpenStarted();
-
-			CurrentDelayTask = Task.Delay(Mathf.RoundToInt(OpenDelayInSeconds));
-
-			await CurrentDelayTask;
-
-			if (gameObject != null)
-			{
-				onOpenedCompleted();
-			}
-		}
-
-		internal async Task CloseWithDelay(Action onCloseCompleted)
-		{
-			OnCloseStarted();
-
-			CurrentDelayTask = Task.Delay(Mathf.RoundToInt(OpenDelayInSeconds));
-
-			await CurrentDelayTask;
-
-			if (gameObject != null)
-			{
-				gameObject.SetActive(false);
-				onCloseCompleted();
-			}
-		}
-	}
-}
diff --git a/Runtime/Delayers/PresenterDelayerBase.cs.meta b/Runtime/Delayers/PresenterDelayerBase.cs.meta
deleted file mode 100644
index 8ec5e8a..0000000
--- a/Runtime/Delayers/PresenterDelayerBase.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 0e4de14537b5e084e95fc21fda41fed9
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Runtime/Delayers/TimeDelayer.cs b/Runtime/Delayers/TimeDelayer.cs
deleted file mode 100644
index e60a0d9..0000000
--- a/Runtime/Delayers/TimeDelayer.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using UnityEngine;
-
-// ReSharper disable CheckNamespace
-
-namespace GameLovers.UiService
-{
-	/// <inheritdoc />
-	/// <remarks>
-	/// Allows this Presenter to have an intro and outro delay on a defined user time.
-	/// </remarks>
-	public class TimeDelayer : PresenterDelayerBase
-	{
-		[SerializeField, Range(0f, float.MaxValue)] protected float _openDelayInSeconds;
-		[SerializeField, Range(0f, float.MaxValue)] protected float _closeDelayInSeconds;
-
-		/// <inheritdoc />
-		public override float OpenDelayInSeconds => _openDelayInSeconds;
-
-		/// <inheritdoc />
-		public override float CloseDelayInSeconds => _closeDelayInSeconds;
-	}
-}
diff --git a/Runtime/Delayers/TimeDelayer.cs.meta b/Runtime/Delayers/TimeDelayer.cs.meta
deleted file mode 100644
index c7a4a37..0000000
--- a/Runtime/Delayers/TimeDelayer.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 5f4c2c15f9d0dc94b8b1bf40e7a61abc
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Runtime/Delayers.meta b/Runtime/Features.meta
similarity index 77%
rename from Runtime/Delayers.meta
rename to Runtime/Features.meta
index f0cf6d6..fee0db9 100644
--- a/Runtime/Delayers.meta
+++ b/Runtime/Features.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 56353040a6f24954695818f027bd4e69
+guid: 28ba3da2408e74c3a86965e175abbc0c
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}
diff --git a/Runtime/Features/AnimationDelayFeature.cs b/Runtime/Features/AnimationDelayFeature.cs
new file mode 100644
index 0000000..e797cf1
--- /dev/null
+++ b/Runtime/Features/AnimationDelayFeature.cs
@@ -0,0 +1,149 @@
+using System;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Feature that adds animation-based delayed opening and closing to a <see cref="UiPresenter"/>.
+	/// Plays intro/outro animations and waits for them to complete.
+	/// </summary>
+	[RequireComponent(typeof(Animation))]
+	public class AnimationDelayFeature : PresenterFeatureBase
+	{
+		[SerializeField] private Animation _animation;
+		[SerializeField] private AnimationClip _introAnimationClip;
+		[SerializeField] private AnimationClip _outroAnimationClip;
+
+		/// <summary>
+		/// Gets the Animation component
+		/// </summary>
+		public Animation AnimationComponent => _animation;
+
+		/// <summary>
+		/// Gets the intro animation clip
+		/// </summary>
+		public AnimationClip IntroAnimationClip => _introAnimationClip;
+
+		/// <summary>
+		/// Gets the outro animation clip
+		/// </summary>
+		public AnimationClip OutroAnimationClip => _outroAnimationClip;
+
+		/// <summary>
+		/// Gets the delay in seconds for opening (based on intro animation length)
+		/// </summary>
+		public float OpenDelayInSeconds => _introAnimationClip?.length ?? 0f;
+
+		/// <summary>
+		/// Gets the delay in seconds for closing (based on outro animation length)
+		/// </summary>
+		public float CloseDelayInSeconds => _outroAnimationClip?.length ?? 0f;
+
+		/// <summary>
+		/// Gets the UniTask of the current delay process
+		/// </summary>
+		public UniTask CurrentDelayTask { get; private set; }
+
+		/// <summary>
+		/// Event triggered when the opening animation is completed
+		/// </summary>
+		internal event Action OnOpenCompletedEvent;
+
+		/// <summary>
+		/// Event triggered when the closing animation is completed
+		/// </summary>
+		internal event Action OnCloseCompletedEvent;
+
+		private void OnValidate()
+		{
+			_animation = _animation ?? GetComponent<Animation>();
+		}
+
+		/// <inheritdoc />
+		public override void OnPresenterOpened()
+		{
+			OpenWithAnimationAsync().Forget();
+		}
+
+		/// <inheritdoc />
+		public override void OnPresenterClosing()
+		{
+			if (Presenter && Presenter.gameObject)
+			{
+				CloseWithAnimationAsync().Forget();
+			}
+		}
+
+		/// <summary>
+		/// Called when the presenter's opening animation starts.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnOpenStarted()
+		{
+			if (!_introAnimationClip)
+			{
+				_animation.clip = _introAnimationClip;
+				_animation.Play();
+			}
+		}
+
+		/// <summary>
+		/// Called when the presenter's opening animation is completed.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnOpenedCompleted()
+		{
+			OnOpenCompletedEvent?.Invoke();
+		}
+
+		/// <summary>
+		/// Called when the presenter's closing animation starts.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnCloseStarted()
+		{
+			if (!_outroAnimationClip)
+			{
+				_animation.clip = _outroAnimationClip;
+				_animation.Play();
+			}
+		}
+
+		/// <summary>
+		/// Called when the presenter's closing animation is completed.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnClosedCompleted()
+		{
+			OnCloseCompletedEvent?.Invoke();
+		}
+
+		private async UniTask OpenWithAnimationAsync()
+		{
+			OnOpenStarted();
+
+			CurrentDelayTask = UniTask.Delay(TimeSpan.FromSeconds(OpenDelayInSeconds));
+			await CurrentDelayTask;
+
+			if (gameObject != null)
+			{
+				OnOpenedCompleted();
+			}
+		}
+
+		private async UniTask CloseWithAnimationAsync()
+		{
+			OnCloseStarted();
+
+			CurrentDelayTask = UniTask.Delay(TimeSpan.FromSeconds(CloseDelayInSeconds));
+			await CurrentDelayTask;
+
+			if (gameObject != null)
+			{
+				gameObject.SetActive(false);
+				OnClosedCompleted();
+			}
+		}
+	}
+}
diff --git a/Runtime/Features/AnimationDelayFeature.cs.meta b/Runtime/Features/AnimationDelayFeature.cs.meta
new file mode 100644
index 0000000..5623071
--- /dev/null
+++ b/Runtime/Features/AnimationDelayFeature.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d794902454b254785899d1bfe209ea82
\ No newline at end of file
diff --git a/Runtime/Features/IPresenterFeature.cs b/Runtime/Features/IPresenterFeature.cs
new file mode 100644
index 0000000..3de3c03
--- /dev/null
+++ b/Runtime/Features/IPresenterFeature.cs
@@ -0,0 +1,36 @@
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Interface for composable presenter features that extend the lifecycle of a <see cref="UiPresenter"/>.
+	/// Features can be attached to presenters to add functionality like delays, animations, or UI Toolkit integration.
+	/// </summary>
+	public interface IPresenterFeature
+	{
+		/// <summary>
+		/// Called when the presenter is initialized. This is invoked once when the presenter is created.
+		/// </summary>
+		/// <param name="presenter">The presenter that owns this feature</param>
+		void OnPresenterInitialized(UiPresenter presenter);
+
+		/// <summary>
+		/// Called when the presenter is being opened. This is invoked before the presenter becomes visible.
+		/// </summary>
+		void OnPresenterOpening();
+
+		/// <summary>
+		/// Called after the presenter has been opened and is now visible.
+		/// </summary>
+		void OnPresenterOpened();
+
+		/// <summary>
+		/// Called when the presenter is being closed. This is invoked before the presenter becomes hidden.
+		/// </summary>
+		void OnPresenterClosing();
+
+		/// <summary>
+		/// Called after the presenter has been closed and is no longer visible.
+		/// </summary>
+		void OnPresenterClosed();
+	}
+}
+
diff --git a/Runtime/Features/IPresenterFeature.cs.meta b/Runtime/Features/IPresenterFeature.cs.meta
new file mode 100644
index 0000000..6d4333d
--- /dev/null
+++ b/Runtime/Features/IPresenterFeature.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 931eb218b994948a39920c4d9127d5fe
\ No newline at end of file
diff --git a/Runtime/Features/PresenterFeatureBase.cs b/Runtime/Features/PresenterFeatureBase.cs
new file mode 100644
index 0000000..ec93ad9
--- /dev/null
+++ b/Runtime/Features/PresenterFeatureBase.cs
@@ -0,0 +1,35 @@
+using UnityEngine;
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Base class for presenter features that can be attached to a <see cref="UiPresenter"/> to extend its functionality.
+	/// Inherit from this class to create custom features that hook into the presenter lifecycle.
+	/// </summary>
+	public abstract class PresenterFeatureBase : MonoBehaviour, IPresenterFeature
+	{
+		/// <summary>
+		/// The presenter that owns this feature
+		/// </summary>
+		protected UiPresenter Presenter { get; private set; }
+
+		/// <inheritdoc />
+		public virtual void OnPresenterInitialized(UiPresenter presenter)
+		{
+			Presenter = presenter;
+		}
+
+		/// <inheritdoc />
+		public virtual void OnPresenterOpening() { }
+
+		/// <inheritdoc />
+		public virtual void OnPresenterOpened() { }
+
+		/// <inheritdoc />
+		public virtual void OnPresenterClosing() { }
+
+		/// <inheritdoc />
+		public virtual void OnPresenterClosed() { }
+	}
+}
+
diff --git a/Runtime/Features/PresenterFeatureBase.cs.meta b/Runtime/Features/PresenterFeatureBase.cs.meta
new file mode 100644
index 0000000..0be1660
--- /dev/null
+++ b/Runtime/Features/PresenterFeatureBase.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e262f2102ce624275bf1a48f11ea3276
\ No newline at end of file
diff --git a/Runtime/Features/TimeDelayFeature.cs b/Runtime/Features/TimeDelayFeature.cs
new file mode 100644
index 0000000..328497d
--- /dev/null
+++ b/Runtime/Features/TimeDelayFeature.cs
@@ -0,0 +1,113 @@
+using System;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Feature that adds time-based delayed opening and closing to a <see cref="UiPresenter"/>.
+	/// Configure delays in seconds directly on this component.
+	/// </summary>
+	public class TimeDelayFeature : PresenterFeatureBase
+	{
+		[SerializeField, Range(0f, float.MaxValue)] private float _openDelayInSeconds = 0.5f;
+		[SerializeField, Range(0f, float.MaxValue)] private float _closeDelayInSeconds = 0.3f;
+
+		/// <summary>
+		/// Gets the delay in seconds before opening the presenter
+		/// </summary>
+		public float OpenDelayInSeconds => _openDelayInSeconds;
+
+		/// <summary>
+		/// Gets the delay in seconds before closing the presenter
+		/// </summary>
+		public float CloseDelayInSeconds => _closeDelayInSeconds;
+
+		/// <summary>
+		/// Gets the UniTask of the current delay process
+		/// </summary>
+		public UniTask CurrentDelayTask { get; private set; }
+
+		/// <summary>
+		/// Event triggered when the opening delay is completed
+		/// </summary>
+		internal event Action OnOpenCompletedEvent;
+
+		/// <summary>
+		/// Event triggered when the closing delay is completed
+		/// </summary>
+		internal event Action OnCloseCompletedEvent;
+
+		/// <inheritdoc />
+		public override void OnPresenterOpened()
+		{
+			OpenWithDelayAsync().Forget();
+		}
+
+		/// <inheritdoc />
+		public override void OnPresenterClosing()
+		{
+			if (Presenter && Presenter.gameObject)
+			{
+				CloseWithDelayAsync().Forget();
+			}
+		}
+
+		/// <summary>
+		/// Called when the presenter's opening delay starts.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnOpenStarted() { }
+
+		/// <summary>
+		/// Called when the presenter's opening delay is completed.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnOpenedCompleted()
+		{
+			OnOpenCompletedEvent?.Invoke();
+		}
+
+		/// <summary>
+		/// Called when the presenter's closing delay starts.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnCloseStarted() { }
+
+		/// <summary>
+		/// Called when the presenter's closing delay is completed.
+		/// Override this in derived classes to add custom behavior.
+		/// </summary>
+		protected virtual void OnClosedCompleted()
+		{
+			OnCloseCompletedEvent?.Invoke();
+		}
+
+		private async UniTask OpenWithDelayAsync()
+		{
+			OnOpenStarted();
+
+			CurrentDelayTask = UniTask.Delay(TimeSpan.FromSeconds(_openDelayInSeconds));
+			await CurrentDelayTask;
+
+			if (gameObject != null)
+			{
+				OnOpenedCompleted();
+			}
+		}
+
+		private async UniTask CloseWithDelayAsync()
+		{
+			OnCloseStarted();
+
+			CurrentDelayTask = UniTask.Delay(TimeSpan.FromSeconds(_closeDelayInSeconds));
+			await CurrentDelayTask;
+
+			if (gameObject != null)
+			{
+				gameObject.SetActive(false);
+				OnClosedCompleted();
+			}
+		}
+	}
+}
diff --git a/Runtime/Features/TimeDelayFeature.cs.meta b/Runtime/Features/TimeDelayFeature.cs.meta
new file mode 100644
index 0000000..90a59a3
--- /dev/null
+++ b/Runtime/Features/TimeDelayFeature.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6ef77186628bc44ecaefb533d6e2143c
\ No newline at end of file
diff --git a/Runtime/Features/UiToolkitPresenterFeature.cs b/Runtime/Features/UiToolkitPresenterFeature.cs
new file mode 100644
index 0000000..4c77904
--- /dev/null
+++ b/Runtime/Features/UiToolkitPresenterFeature.cs
@@ -0,0 +1,31 @@
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Feature that provides UI Toolkit integration for a <see cref="UiPresenter"/>.
+	/// Ensures a <see cref="UIDocument"/> is present and provides access to it.
+	/// </summary>
+	[RequireComponent(typeof(UIDocument))]
+	public class UiToolkitPresenterFeature : PresenterFeatureBase
+	{
+		[SerializeField] private UIDocument _document;
+
+		/// <summary>
+		/// Provides access to the attached <see cref="UIDocument"/>
+		/// </summary>
+		public UIDocument Document => _document;
+
+		/// <summary>
+		/// The root element of the <see cref="UIDocument"/>
+		/// </summary>
+		public VisualElement Root => _document?.rootVisualElement;
+
+		private void OnValidate()
+		{
+			_document = _document ?? GetComponent<UIDocument>();
+		}
+	}
+}
+
diff --git a/Runtime/Features/UiToolkitPresenterFeature.cs.meta b/Runtime/Features/UiToolkitPresenterFeature.cs.meta
new file mode 100644
index 0000000..b83978f
--- /dev/null
+++ b/Runtime/Features/UiToolkitPresenterFeature.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8c5d659424979427c91d040dff11e6d9
\ No newline at end of file
diff --git a/Runtime/IUiService.cs b/Runtime/IUiService.cs
index 58d610a..5f4b77a 100644
--- a/Runtime/IUiService.cs
+++ b/Runtime/IUiService.cs
@@ -1,7 +1,7 @@
 using Cysharp.Threading.Tasks;
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
+using System.Threading;
 using UnityEngine;
 
 // ReSharper disable CheckNamespace
@@ -9,31 +9,58 @@
 namespace GameLovers.UiService
 {
 	/// <summary>
-	/// This service provides an abstraction layer to interact with the game's UI <seealso cref="UiPresenter"/>
-	/// The Ui Service is organized by layers. The higher the layer the more close is to the camera viewport
+	/// Represents a UI presenter instance with its type, address and presenter reference
 	/// </summary>
-	public interface IUiService
+	public readonly struct UiInstance
 	{
 		/// <summary>
-		/// Gets a read-only dictionary of the Presenters currently Loaded in memory by the UI service.
+		/// The type of the UI presenter
+		/// </summary>
+		public readonly Type Type;
+		
+		/// <summary>
+		/// The instance address (empty string for default/singleton instances)
 		/// </summary>
-		IReadOnlyDictionary<Type, UiPresenter> LoadedPresenters { get; }
+		public readonly string Address;
 		
 		/// <summary>
-		/// Gets a read-only list of the Presenters currently currently visible and were opened by the UI service.
+		/// The UI presenter reference
 		/// </summary>
-		IReadOnlyList<Type> VisiblePresenters { get; }
+		public readonly UiPresenter Presenter;
 
+		public UiInstance(Type type, string address, UiPresenter presenter)
+		{
+			Type = type;
+			Address = address;
+			Presenter = presenter;
+		}
+	}
+
+	/// <summary>
+	/// This service provides an abstraction layer to interact with the game's UI <seealso cref="UiPresenter"/>
+	/// The Ui Service is organized by layers. The higher the layer the more close is to the camera viewport.
+	/// Supports multiple instances of the same UI type through the UiInstanceId system.
+	/// </summary>
+	public interface IUiService
+	{
+		
 		/// <summary>
-		/// Gets a read-only dictionary of the layers used by the UI service.
+		/// Gets a read-only list of all Presenter instances currently visible.
+		/// Each entry is a UiInstanceId containing the Type and instance name.
 		/// </summary>
-		IReadOnlyDictionary<int, GameObject> Layers { get; }
+		IReadOnlyList<UiInstanceId> VisiblePresenters { get; }
 
 		/// <summary>
 		/// Gets a read-only dictionary of the containers of UI, called 'Ui Set' maintained by the UI service.
 		/// </summary>
 		IReadOnlyDictionary<int, UiSetConfig> UiSets { get; }
 
+		/// <summary>
+		/// Gets all UI presenters currently loaded in memory by the UI service.
+		/// </summary>
+		/// <returns>A list of all loaded UI instances</returns>
+		List<UiInstance> GetLoadedPresenters();
+
 		/// <summary>
 		/// Requests the UI of given type <typeparamref name="T"/>
 		/// </summary>
@@ -110,9 +137,10 @@ public interface IUiService
 		/// </summary>
 		/// <typeparam name="T">The type of UI to load.</typeparam>
 		/// <param name="openAfter">Whether to open the UI after loading.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes with the loaded UI.</returns>
 		/// <exception cref="KeyNotFoundException">Thrown if the service does not contain a UI configuration for the specified type.</exception>
-		async UniTask<T> LoadUiAsync<T>(bool openAfter = false) where T : UiPresenter => (await LoadUiAsync(typeof(T), openAfter)) as T;
+		async UniTask<T> LoadUiAsync<T>(bool openAfter = false, CancellationToken cancellationToken = default) where T : UiPresenter => (await LoadUiAsync(typeof(T), openAfter, cancellationToken)) as T;
 
 		/// <summary>
 		/// Loads the UI of the specified type asynchronously.
@@ -121,9 +149,10 @@ public interface IUiService
 		/// </summary>
 		/// <param name="type">The type of UI to load.</param>
 		/// <param name="openAfter">Whether to open the UI after loading.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes with the loaded UI.</returns>
 		/// <exception cref="KeyNotFoundException">Thrown if the service does not contain a UI configuration for the specified type.</exception>
-		UniTask<UiPresenter> LoadUiAsync(Type type, bool openAfter = false);
+		UniTask<UiPresenter> LoadUiAsync(Type type, bool openAfter = false, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		/// Loads all UI presenters from the specified UI set asynchronously.
@@ -168,15 +197,17 @@ public interface IUiService
 		/// Opens a UI presenter asynchronously, loading its assets if necessary.
 		/// </summary>
 		/// <typeparam name="T">The type of UI presenter to open.</typeparam>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes when the UI presenter is opened.</returns>
-		async UniTask<T> OpenUiAsync<T>() where T : UiPresenter => (await OpenUiAsync(typeof(T))) as T;
+		async UniTask<T> OpenUiAsync<T>(CancellationToken cancellationToken = default) where T : UiPresenter => (await OpenUiAsync(typeof(T), cancellationToken)) as T;
 
 		/// <summary>
 		/// Opens a UI presenter asynchronously, loading its assets if necessary.
 		/// </summary>
 		/// <param name="type">The type of UI presenter to open.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes when the UI presenter is opened.</returns>
-		UniTask<UiPresenter> OpenUiAsync(Type type);
+		UniTask<UiPresenter> OpenUiAsync(Type type, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		/// Opens a UI presenter asynchronously, loading its assets if necessary, and sets its initial data.
@@ -184,18 +215,20 @@ public interface IUiService
 		/// <typeparam name="T">The type of UI presenter to open.</typeparam>
 		/// <typeparam name="TData">The type of initial data to set.</typeparam>
 		/// <param name="initialData">The initial data to set.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes when the UI presenter is opened.</returns>
-		async UniTask<T> OpenUiAsync<T, TData>(TData initialData) 
+		async UniTask<T> OpenUiAsync<T, TData>(TData initialData, CancellationToken cancellationToken = default) 
 			where T : class, IUiPresenterData 
-			where TData : struct => await OpenUiAsync(typeof(T), initialData) as T;
+			where TData : struct => await OpenUiAsync(typeof(T), initialData, cancellationToken) as T;
 
 		/// <summary>
 		/// Opens a UI presenter asynchronously, loading its assets if necessary, and sets its initial data.
 		/// </summary>
 		/// <param name="type">The type of UI presenter to open.</param>
 		/// <param name="initialData">The initial data to set.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
 		/// <returns>A task that completes when the UI presenter is opened.</returns>
-		UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialData) where TData : struct;
+		UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialData, CancellationToken cancellationToken = default) where TData : struct;
 
 		/// <summary>
 		/// Closes a UI presenter and optionally destroys its assets.
@@ -242,7 +275,7 @@ async UniTask<T> OpenUiAsync<T, TData>(TData initialData)
 	/// <remarks>
 	/// This interface provides a way to initialize the UI service with the game's UI configurations.
 	/// </remarks>
-	public interface IUiServiceInit : IUiService
+	public interface IUiServiceInit : IUiService, IDisposable
 	{
 		/// <summary>
 		/// Initializes the UI service with the given UI configurations.
@@ -251,9 +284,15 @@ public interface IUiServiceInit : IUiService
 		/// <remarks>
 		/// To help configure the game's UI, you need to create a UiConfigs Scriptable object by:
 		/// - Right Click on the Project View > Create > ScriptableObjects > Configs > UiConfigs
+		/// - Duplicate UI configs or UI sets will log warnings but will not throw exceptions
+		/// - Layer numbers below 0 or above 1000 will log warnings
+		/// - Empty addressable addresses or null UI types will throw ArgumentException
 		/// </remarks>
+		/// <exception cref="ArgumentNullException">
+		/// Thrown if <paramref name="configs"/> is null.
+		/// </exception>
 		/// <exception cref="ArgumentException">
-		/// Thrown if any of the <see cref="UiConfig"/> in the given <paramref name="configs"/> is duplicated.
+		/// Thrown if any UI config has an empty addressable address or null UI type.
 		/// </exception>
 		void Init(UiConfigs configs);
 	}
diff --git a/Runtime/UiAnalytics.cs b/Runtime/UiAnalytics.cs
new file mode 100644
index 0000000..d11432f
--- /dev/null
+++ b/Runtime/UiAnalytics.cs
@@ -0,0 +1,398 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+// ReSharper disable CheckNamespace
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Event data for UI lifecycle events
+	/// </summary>
+	public struct UiEventData
+	{
+		public Type UiType;
+		public string UiName;
+		public int Layer;
+		public float Timestamp;
+		public bool WasDestroyed;
+
+		public UiEventData(Type uiType, int layer, bool wasDestroyed = false)
+		{
+			UiType = uiType;
+			UiName = uiType.Name;
+			Layer = layer;
+			Timestamp = Time.time;
+			WasDestroyed = wasDestroyed;
+		}
+	}
+
+	/// <summary>
+	/// Performance metrics for UI operations
+	/// </summary>
+	public struct UiPerformanceMetrics
+	{
+		public Type UiType;
+		public string UiName;
+		public float LoadDuration;
+		public float OpenDuration;
+		public float CloseDuration;
+		public float TotalLifetime;
+		public int OpenCount;
+		public int CloseCount;
+		public DateTime FirstOpened;
+		public DateTime LastClosed;
+
+		public UiPerformanceMetrics(Type uiType)
+		{
+			UiType = uiType;
+			UiName = uiType.Name;
+			LoadDuration = 0f;
+			OpenDuration = 0f;
+			CloseDuration = 0f;
+			TotalLifetime = 0f;
+			OpenCount = 0;
+			CloseCount = 0;
+			FirstOpened = DateTime.MinValue;
+			LastClosed = DateTime.MinValue;
+		}
+	}
+
+	/// <summary>
+	/// Callback interface for custom analytics integration
+	/// </summary>
+	public interface IUiAnalyticsCallback
+	{
+		/// <summary>
+		/// Called when a UI has been loaded into memory
+		/// </summary>
+		/// <param name="data">Event data containing UI type, name, layer, and timestamp</param>
+		void OnUiLoaded(UiEventData data);
+		
+		/// <summary>
+		/// Called when a UI has been opened and made visible
+		/// </summary>
+		/// <param name="data">Event data containing UI type, name, layer, and timestamp</param>
+		void OnUiOpened(UiEventData data);
+		
+		/// <summary>
+		/// Called when a UI has been closed and hidden
+		/// </summary>
+		/// <param name="data">Event data containing UI type, name, layer, timestamp, and destruction status</param>
+		void OnUiClosed(UiEventData data);
+		
+		/// <summary>
+		/// Called when a UI has been unloaded from memory
+		/// </summary>
+		/// <param name="data">Event data containing UI type, name, layer, and timestamp</param>
+		void OnUiUnloaded(UiEventData data);
+		
+		/// <summary>
+		/// Called when performance metrics for a UI have been updated
+		/// </summary>
+		/// <param name="metrics">Performance metrics including load/open/close durations, counts, and lifetime</param>
+		void OnPerformanceMetricsUpdated(UiPerformanceMetrics metrics);
+	}
+
+	/// <summary>
+	/// Interface for UI analytics tracking
+	/// </summary>
+	public interface IUiAnalytics
+	{
+		/// <summary>
+		/// Gets all performance metrics for all tracked UIs
+		/// </summary>
+		IReadOnlyDictionary<Type, UiPerformanceMetrics> PerformanceMetrics { get; }
+
+		/// <summary>
+		/// Unity Events for easy integration
+		/// </summary>
+		UnityEvent<UiEventData> OnUiLoaded { get; }
+		UnityEvent<UiEventData> OnUiOpened { get; }
+		UnityEvent<UiEventData> OnUiClosed { get; }
+		UnityEvent<UiEventData> OnUiUnloaded { get; }
+		UnityEvent<UiPerformanceMetrics> OnPerformanceMetricsUpdated { get; }
+
+		/// <summary>
+		/// Sets a custom callback for analytics events
+		/// </summary>
+		void SetCallback(IUiAnalyticsCallback callback);
+
+		/// <summary>
+		/// Clears all analytics data
+		/// </summary>
+		void Clear();
+
+		/// <summary>
+		/// Gets performance metrics for a specific UI type
+		/// </summary>
+		UiPerformanceMetrics GetMetrics(Type uiType);
+
+		/// <summary>
+		/// Logs a summary of all performance metrics to the console
+		/// </summary>
+		void LogPerformanceSummary();
+
+		/// <summary>
+		/// Tracks the start of a UI load operation
+		/// </summary>
+		void TrackLoadStart(Type uiType);
+
+		/// <summary>
+		/// Tracks the completion of a UI load operation
+		/// </summary>
+		void TrackLoadComplete(Type uiType, int layer);
+
+		/// <summary>
+		/// Tracks the start of a UI open operation
+		/// </summary>
+		void TrackOpenStart(Type uiType);
+
+		/// <summary>
+		/// Tracks the completion of a UI open operation
+		/// </summary>
+		void TrackOpenComplete(Type uiType, int layer);
+
+		/// <summary>
+		/// Tracks the start of a UI close operation
+		/// </summary>
+		void TrackCloseStart(Type uiType);
+
+		/// <summary>
+		/// Tracks the completion of a UI close operation
+		/// </summary>
+		void TrackCloseComplete(Type uiType, int layer, bool destroyed);
+
+		/// <summary>
+		/// Tracks a UI unload operation
+		/// </summary>
+		void TrackUnload(Type uiType, int layer);
+	}
+
+	/// <summary>
+	/// Analytics system for tracking UI events and performance
+	/// </summary>
+	public class UiAnalytics : IUiAnalytics
+	{
+		// Performance tracking
+		private readonly Dictionary<Type, UiPerformanceMetrics> _performanceMetrics = new Dictionary<Type, UiPerformanceMetrics>();
+		private readonly Dictionary<Type, float> _loadStartTimes = new Dictionary<Type, float>();
+		private readonly Dictionary<Type, float> _openStartTimes = new Dictionary<Type, float>();
+		private readonly Dictionary<Type, float> _closeStartTimes = new Dictionary<Type, float>();
+		private readonly Dictionary<Type, float> _firstOpenTimes = new Dictionary<Type, float>();
+
+		// Optional callback for custom analytics
+		private IUiAnalyticsCallback _callback;
+		
+		// Unity Events for easy integration
+		public UnityEvent<UiEventData> OnUiLoaded { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiOpened { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiClosed { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiUnloaded { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiPerformanceMetrics> OnPerformanceMetricsUpdated { get; } = new UnityEvent<UiPerformanceMetrics>();
+
+		/// <summary>
+		/// Gets all performance metrics for all tracked UIs
+		/// </summary>
+		public IReadOnlyDictionary<Type, UiPerformanceMetrics> PerformanceMetrics => _performanceMetrics;
+
+		/// <summary>
+		/// Sets a custom callback for analytics events
+		/// </summary>
+		public void SetCallback(IUiAnalyticsCallback callback)
+		{
+			_callback = callback;
+		}
+
+		/// <summary>
+		/// Clears all analytics data
+		/// </summary>
+		public void Clear()
+		{
+			_performanceMetrics.Clear();
+			_loadStartTimes.Clear();
+			_openStartTimes.Clear();
+			_closeStartTimes.Clear();
+			_firstOpenTimes.Clear();
+		}
+
+		/// <summary>
+		/// Gets performance metrics for a specific UI type
+		/// </summary>
+		public UiPerformanceMetrics GetMetrics(Type uiType)
+		{
+			return _performanceMetrics.TryGetValue(uiType, out var metrics) 
+				? metrics 
+				: new UiPerformanceMetrics(uiType);
+		}
+
+		public void TrackLoadStart(Type uiType)
+		{
+			_loadStartTimes[uiType] = Time.realtimeSinceStartup;
+		}
+
+		public void TrackLoadComplete(Type uiType, int layer)
+		{
+			var duration = 0f;
+			if (_loadStartTimes.TryGetValue(uiType, out var startTime))
+			{
+				duration = Time.realtimeSinceStartup - startTime;
+				_loadStartTimes.Remove(uiType);
+			}
+
+			UpdateMetrics(uiType, metrics =>
+			{
+				metrics.LoadDuration = duration;
+				return metrics;
+			});
+
+			var eventData = new UiEventData(uiType, layer);
+			OnUiLoaded.Invoke(eventData);
+			_callback?.OnUiLoaded(eventData);
+		}
+
+		public void TrackOpenStart(Type uiType)
+		{
+			_openStartTimes[uiType] = Time.realtimeSinceStartup;
+			
+			if (!_firstOpenTimes.ContainsKey(uiType))
+			{
+				_firstOpenTimes[uiType] = Time.realtimeSinceStartup;
+			}
+		}
+
+		public void TrackOpenComplete(Type uiType, int layer)
+		{
+			var duration = 0f;
+			if (_openStartTimes.TryGetValue(uiType, out var startTime))
+			{
+				duration = Time.realtimeSinceStartup - startTime;
+				_openStartTimes.Remove(uiType);
+			}
+
+			UpdateMetrics(uiType, metrics =>
+			{
+				metrics.OpenDuration = duration;
+				metrics.OpenCount++;
+				if (metrics.FirstOpened == DateTime.MinValue)
+				{
+					metrics.FirstOpened = DateTime.Now;
+				}
+				return metrics;
+			});
+
+			var eventData = new UiEventData(uiType, layer);
+			OnUiOpened.Invoke(eventData);
+			_callback?.OnUiOpened(eventData);
+		}
+
+		public void TrackCloseStart(Type uiType)
+		{
+			_closeStartTimes[uiType] = Time.realtimeSinceStartup;
+		}
+
+		public void TrackCloseComplete(Type uiType, int layer, bool destroyed)
+		{
+			var duration = 0f;
+			if (_closeStartTimes.TryGetValue(uiType, out var startTime))
+			{
+				duration = Time.realtimeSinceStartup - startTime;
+				_closeStartTimes.Remove(uiType);
+			}
+
+			// Calculate lifetime
+			var lifetime = 0f;
+			if (_firstOpenTimes.TryGetValue(uiType, out var firstOpenTime))
+			{
+				lifetime = Time.realtimeSinceStartup - firstOpenTime;
+			}
+
+			UpdateMetrics(uiType, metrics =>
+			{
+				metrics.CloseDuration = duration;
+				metrics.CloseCount++;
+				metrics.TotalLifetime = lifetime;
+				metrics.LastClosed = DateTime.Now;
+				return metrics;
+			});
+
+			var eventData = new UiEventData(uiType, layer, destroyed);
+			OnUiClosed.Invoke(eventData);
+			_callback?.OnUiClosed(eventData);
+		}
+
+		public void TrackUnload(Type uiType, int layer)
+		{
+			var eventData = new UiEventData(uiType, layer, true);
+			OnUiUnloaded.Invoke(eventData);
+			_callback?.OnUiUnloaded(eventData);
+
+			// Clean up tracking data
+			_firstOpenTimes.Remove(uiType);
+		}
+
+		private void UpdateMetrics(Type uiType, Func<UiPerformanceMetrics, UiPerformanceMetrics> updateFunc)
+		{
+			if (!_performanceMetrics.ContainsKey(uiType))
+			{
+				_performanceMetrics[uiType] = new UiPerformanceMetrics(uiType);
+			}
+
+			_performanceMetrics[uiType] = updateFunc(_performanceMetrics[uiType]);
+			OnPerformanceMetricsUpdated.Invoke(_performanceMetrics[uiType]);
+			_callback?.OnPerformanceMetricsUpdated(_performanceMetrics[uiType]);
+		}
+
+		/// <summary>
+		/// Logs a summary of all performance metrics to the console
+		/// </summary>
+		public void LogPerformanceSummary()
+		{
+			Debug.Log("=== UI Service Performance Summary ===");
+			
+			foreach (var kvp in _performanceMetrics)
+			{
+				var metrics = kvp.Value;
+				Debug.Log($"\n{metrics.UiName}:");
+				Debug.Log($"  Load Time: {metrics.LoadDuration:F3}s");
+				Debug.Log($"  Avg Open Time: {metrics.OpenDuration:F3}s");
+				Debug.Log($"  Avg Close Time: {metrics.CloseDuration:F3}s");
+				Debug.Log($"  Open Count: {metrics.OpenCount}");
+				Debug.Log($"  Close Count: {metrics.CloseCount}");
+				Debug.Log($"  Total Lifetime: {metrics.TotalLifetime:F1}s");
+			}
+			
+			Debug.Log("\n======================================");
+		}
+	}
+
+	/// <summary>
+	/// Null implementation of IUiAnalytics that does nothing. Used when analytics is disabled.
+	/// </summary>
+	public class NullAnalytics : IUiAnalytics
+	{
+		private static readonly IReadOnlyDictionary<Type, UiPerformanceMetrics> EmptyMetrics = new Dictionary<Type, UiPerformanceMetrics>();
+		
+		public IReadOnlyDictionary<Type, UiPerformanceMetrics> PerformanceMetrics => EmptyMetrics;
+		
+		public UnityEvent<UiEventData> OnUiLoaded { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiOpened { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiClosed { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiEventData> OnUiUnloaded { get; } = new UnityEvent<UiEventData>();
+		public UnityEvent<UiPerformanceMetrics> OnPerformanceMetricsUpdated { get; } = new UnityEvent<UiPerformanceMetrics>();
+		
+		public void SetCallback(IUiAnalyticsCallback callback) { }
+		public void Clear() { }
+		public UiPerformanceMetrics GetMetrics(Type uiType) => new UiPerformanceMetrics(uiType);
+		public void LogPerformanceSummary() { }
+		public void TrackLoadStart(Type uiType) { }
+		public void TrackLoadComplete(Type uiType, int layer) { }
+		public void TrackOpenStart(Type uiType) { }
+		public void TrackOpenComplete(Type uiType, int layer) { }
+		public void TrackCloseStart(Type uiType) { }
+		public void TrackCloseComplete(Type uiType, int layer, bool destroyed) { }
+		public void TrackUnload(Type uiType, int layer) { }
+	}
+}
+
diff --git a/Runtime/UiAnalytics.cs.meta b/Runtime/UiAnalytics.cs.meta
new file mode 100644
index 0000000..153afbd
--- /dev/null
+++ b/Runtime/UiAnalytics.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 443ad038aae9a4ff395653e7d3d4fcf0
\ No newline at end of file
diff --git a/Runtime/UiAssetLoader.cs b/Runtime/UiAssetLoader.cs
index 07fc2a2..61ff06d 100644
--- a/Runtime/UiAssetLoader.cs
+++ b/Runtime/UiAssetLoader.cs
@@ -1,4 +1,5 @@
 using Cysharp.Threading.Tasks;
+using System.Threading;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
 using UnityEngine.ResourceManagement.AsyncOperations;
@@ -13,13 +14,14 @@ namespace GameLovers.UiService
 	/// </summary>
 	public interface IUiAssetLoader
 	{
-		/// <summary>
-		/// Instantiates the prefab asynchronously with the given <paramref name="config"/> and <paramref name="parent"/>.
-		/// </summary>
-		/// <param name="config">The UI configuration to instantiate.</param>
-		/// <param name="parent">The parent transform to instantiate the prefab under.</param>
-		/// <returns>A task that completes with the instantiated prefab game object.</returns>
-		UniTask<GameObject> InstantiatePrefab(UiConfig config, Transform parent);
+	/// <summary>
+	/// Instantiates the prefab asynchronously with the given <paramref name="config"/> and <paramref name="parent"/>.
+	/// </summary>
+	/// <param name="config">The UI configuration to instantiate.</param>
+	/// <param name="parent">The parent transform to instantiate the prefab under.</param>
+	/// <param name="cancellationToken">Cancellation token to cancel the operation.</param>
+	/// <returns>A task that completes with the instantiated prefab game object.</returns>
+	UniTask<GameObject> InstantiatePrefab(UiConfig config, Transform parent, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		/// Unloads the given <paramref name="asset"/> from the game memory
@@ -30,27 +32,27 @@ public interface IUiAssetLoader
 	/// <inheritdoc />
 	public class UiAssetLoader : IUiAssetLoader
 	{
-		/// <inheritdoc />
-		public async UniTask<GameObject> InstantiatePrefab(UiConfig config, Transform parent)
+	/// <inheritdoc />
+	public async UniTask<GameObject> InstantiatePrefab(UiConfig config, Transform parent, CancellationToken cancellationToken = default)
+	{
+		var operation = Addressables.InstantiateAsync(config.AddressableAddress, new InstantiationParameters(parent, false));
+
+		if(config.LoadSynchronously)
 		{
-			var operation = Addressables.InstantiateAsync(config.AddressableAddress, new InstantiationParameters(parent, false));
-
-			if(config.LoadSynchronously)
-			{
-				operation.WaitForCompletion();
-			}
-			else
-			{
-				await operation.Task;
-			}
-
-			if (operation.Status != AsyncOperationStatus.Succeeded)
-			{
-				throw operation.OperationException;
-			}
-
-			return operation.Result;
+			operation.WaitForCompletion();
 		}
+		else
+		{
+			await operation.ToUniTask(cancellationToken: cancellationToken);
+		}
+
+		if (operation.Status != AsyncOperationStatus.Succeeded)
+		{
+			throw operation.OperationException;
+		}
+
+		return operation.Result;
+	}
 
 		/// <inheritdoc />
 		public void UnloadAsset(GameObject asset)
diff --git a/Runtime/UiConfigs.cs b/Runtime/UiConfigs.cs
index 1f44e12..59e56e7 100644
--- a/Runtime/UiConfigs.cs
+++ b/Runtime/UiConfigs.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 
 // ReSharper disable CheckNamespace
@@ -25,30 +26,11 @@ public struct UiConfig
 	[CreateAssetMenu(fileName = "UiConfigs", menuName = "ScriptableObjects/Configs/UiConfigs")]
 	public class UiConfigs : ScriptableObject//, IConfigsContainer<UiConfig>
 	{
-		[SerializeField] private string _loadingSpinnerType;
 		[SerializeField]
 		private List<UiConfigSerializable> _configs = new List<UiConfigSerializable>();
 		[SerializeField]
 		private List<UiSetConfigSerializable> _sets = new List<UiSetConfigSerializable>();
 
-		/// <summary>
-		/// Gets or sets the type of the loading spinner
-		/// </summary>
-		public Type LoadingSpinnerType
-		{
-			get => String.IsNullOrEmpty(_loadingSpinnerType) ? null : Type.GetType(_loadingSpinnerType);
-			set => _loadingSpinnerType = value?.GetType().AssemblyQualifiedName;
-		}
-
-		/// <summary>
-		/// Gets or sets the type of the loading spinner as a string
-		/// </summary>
-		public string LoadingSpinnerTypeString
-		{
-			get => _loadingSpinnerType;
-			set => _loadingSpinnerType = value;
-		}
-
 		/// <summary>
 		/// Gets or sets the list of UI configurations
 		/// </summary>
@@ -61,15 +43,18 @@ public List<UiConfig> Configs
 		/// <summary>
 		/// Gets the list of UI set configurations
 		/// </summary>
-		public List<UiSetConfig> Sets => _sets.ConvertAll(element => (UiSetConfig)element);
+		public List<UiSetConfig> Sets => _sets.ConvertAll(element => UiSetConfigSerializable.ToUiSetConfig(element));
 
 		/// <summary>
 		/// Sets the new size of this scriptable object <seealso cref="UiSetConfig"/> list.
-		/// The UiConfigSets have the same id value that the index in the list
+		/// The UiConfigSets have the same id value that the index in the list.
+		/// Validates entries against available UI configs.
 		/// </summary>
 		/// <param name="size">The new size of the list</param>
 		public void SetSetsSize(int size)
 		{
+			var validTypeNames = new HashSet<string>(_configs.Select(c => c.UiType));
+			
 			if (size < _sets.Count)
 			{
 				_sets.RemoveRange(size, _sets.Count - size);
@@ -79,23 +64,21 @@ public void SetSetsSize(int size)
 			{
 				if (i < _sets.Count)
 				{
-					var cleanedConfigList = new List<string>(_sets[i].UiConfigsType.Count);
-
-					foreach (var uiConfig in _sets[i].UiConfigsType)
+					var set = _sets[i];
+					
+					// Initialize UiEntries if null
+					if (set.UiEntries == null)
 					{
-						if (_configs.FindIndex(config => config.UiType == uiConfig) > -1)
-						{
-							cleanedConfigList.Add(uiConfig);
-						}
+						set.UiEntries = new List<UiSetEntry>();
 					}
-
-					var set = _sets[i];
-					set.UiConfigsType = cleanedConfigList;
+					
+					// Remove entries that reference non-existent UI types
+					set.UiEntries.RemoveAll(entry => !validTypeNames.Contains(entry.UiTypeName));
 					_sets[i] = set;
 					continue;
 				}
 
-				_sets.Add(new UiSetConfigSerializable { SetId = i, UiConfigsType = new List<string>() });
+				_sets.Add(new UiSetConfigSerializable { SetId = i, UiEntries = new List<UiSetEntry>() });
 			}
 		}
 
@@ -115,45 +98,21 @@ public static implicit operator UiConfig(UiConfigSerializable serializable)
 				{
 					AddressableAddress = serializable.AddressableAddress,
 					Layer = serializable.Layer,
-					UiType = Type.GetType(serializable.UiType)
+					UiType = Type.GetType(serializable.UiType),
+					LoadSynchronously = false
 				};
 			}
 
-			public static implicit operator UiConfigSerializable(UiConfig serializable)
+			public static implicit operator UiConfigSerializable(UiConfig config)
 			{
 				return new UiConfigSerializable
 				{
-					AddressableAddress = serializable.AddressableAddress,
-					Layer = serializable.Layer,
-					UiType = serializable.UiType.AssemblyQualifiedName
+					AddressableAddress = config.AddressableAddress,
+					Layer = config.Layer,
+					UiType = config.UiType.AssemblyQualifiedName
 				};
 			}
 		}
 
-		/// <summary>
-		/// Necessary to serialize the data in scriptable object
-		/// </summary>
-		[Serializable]
-		public struct UiSetConfigSerializable
-		{
-			public int SetId;
-			public List<string> UiConfigsType;
-
-			public static implicit operator UiSetConfig(UiSetConfigSerializable serializable)
-			{
-				var configs = new List<Type>();
-
-				foreach (var uiConfig in serializable.UiConfigsType)
-				{
-					configs.Add(Type.GetType(uiConfig));
-				}
-
-				return new UiSetConfig
-				{
-					SetId = serializable.SetId,
-					UiConfigsType = configs.AsReadOnly()
-				};
-			}
-		}
 	}
 }
\ No newline at end of file
diff --git a/Runtime/UiInstanceId.cs b/Runtime/UiInstanceId.cs
new file mode 100644
index 0000000..a21f55e
--- /dev/null
+++ b/Runtime/UiInstanceId.cs
@@ -0,0 +1,83 @@
+using System;
+
+// ReSharper disable CheckNamespace
+
+namespace GameLovers.UiService
+{
+	/// <summary>
+	/// Represents a unique identifier for a UI presenter instance.
+	/// Combines the presenter type with an optional instance address to support multiple instances of the same type.
+	/// </summary>
+	public readonly struct UiInstanceId : IEquatable<UiInstanceId>
+	{
+		/// <summary>
+		/// The type of the UI presenter
+		/// </summary>
+		public readonly Type PresenterType;
+		
+		/// <summary>
+		/// Optional instance address. If null or empty, this represents the default/singleton instance.
+		/// </summary>
+		public readonly string InstanceAddress;
+
+		/// <summary>
+		/// Creates a UI instance identifier for a specific presenter type and optional instance address
+		/// </summary>
+		/// <param name="presenterType">The type of the UI presenter</param>
+		/// <param name="instanceAddress">Optional instance address. Use null or empty string for singleton instances.</param>
+		public UiInstanceId(Type presenterType, string instanceAddress = null)
+		{
+			PresenterType = presenterType ?? throw new ArgumentNullException(nameof(presenterType));
+			InstanceAddress = string.IsNullOrEmpty(instanceAddress) ? string.Empty : instanceAddress;
+		}
+
+		/// <summary>
+		/// Creates a default instance ID for a presenter type (singleton)
+		/// </summary>
+		public static UiInstanceId Default(Type presenterType) => new UiInstanceId(presenterType);
+
+		/// <summary>
+		/// Creates a named instance ID for a presenter type
+		/// </summary>
+		public static UiInstanceId Named(Type presenterType, string instanceAddress) => new UiInstanceId(presenterType, instanceAddress);
+
+		/// <summary>
+		/// Checks if this is a default/singleton instance (no specific instance address)
+		/// </summary>
+		public bool IsDefault => string.IsNullOrEmpty(InstanceAddress);
+
+		public bool Equals(UiInstanceId other)
+		{
+			return PresenterType == other.PresenterType && InstanceAddress == other.InstanceAddress;
+		}
+
+		public override bool Equals(object obj)
+		{
+			return obj is UiInstanceId other && Equals(other);
+		}
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				return ((PresenterType != null ? PresenterType.GetHashCode() : 0) * 397) ^ (InstanceAddress != null ? InstanceAddress.GetHashCode() : 0);
+			}
+		}
+
+		public static bool operator ==(UiInstanceId left, UiInstanceId right)
+		{
+			return left.Equals(right);
+		}
+
+		public static bool operator !=(UiInstanceId left, UiInstanceId right)
+		{
+			return !left.Equals(right);
+		}
+
+		public override string ToString()
+		{
+			return IsDefault ? $"{PresenterType.Name}" : $"{PresenterType.Name}:{InstanceAddress}";
+		}
+	}
+}
+
diff --git a/Runtime/UiInstanceId.cs.meta b/Runtime/UiInstanceId.cs.meta
new file mode 100644
index 0000000..05a73de
--- /dev/null
+++ b/Runtime/UiInstanceId.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 503a17b33c0f448069a6b71e10673bfc
\ No newline at end of file
diff --git a/Runtime/UiPresenter.cs b/Runtime/UiPresenter.cs
index d27f5f5..00fdb35 100644
--- a/Runtime/UiPresenter.cs
+++ b/Runtime/UiPresenter.cs
@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
 using UnityEngine;
 
 // ReSharper disable CheckNamespace
@@ -20,6 +20,7 @@ public interface IUiPresenterData
 	public abstract class UiPresenter : MonoBehaviour
 	{
 		protected IUiService _uiService;
+		private List<IPresenterFeature> _features;
 
 		/// <summary>
 		/// Requests the open status of the <see cref="UiPresenter"/>
@@ -52,19 +53,25 @@ protected virtual void OnClosed() {}
 		internal void Init(IUiService uiService)
 		{
 			_uiService = uiService;
+			InitializeFeatures();
 			OnInitialized();
 		}
 
 		internal void InternalOpen()
 		{
+			NotifyFeaturesOpening();
+			
 			gameObject.SetActive(true);
 
 			OnOpened();
+			NotifyFeaturesOpened();
 		}
 
 		internal virtual void InternalClose(bool destroy)
 		{
+			NotifyFeaturesClosing();
 			OnClosed();
+			NotifyFeaturesClosed();
 
 			if (gameObject == null)
 			{
@@ -80,6 +87,57 @@ internal virtual void InternalClose(bool destroy)
 				gameObject.SetActive(false);
 			}
 		}
+
+		private void InitializeFeatures()
+		{
+			_features = new List<IPresenterFeature>();
+			GetComponents(_features);
+
+			foreach (var feature in _features)
+			{
+				feature.OnPresenterInitialized(this);
+			}
+		}
+
+		private void NotifyFeaturesOpening()
+		{
+			if (_features == null) return;
+			
+			foreach (var feature in _features)
+			{
+				feature.OnPresenterOpening();
+			}
+		}
+
+		private void NotifyFeaturesOpened()
+		{
+			if (_features == null) return;
+			
+			foreach (var feature in _features)
+			{
+				feature.OnPresenterOpened();
+			}
+		}
+
+		private void NotifyFeaturesClosing()
+		{
+			if (_features == null) return;
+			
+			foreach (var feature in _features)
+			{
+				feature.OnPresenterClosing();
+			}
+		}
+
+		private void NotifyFeaturesClosed()
+		{
+			if (_features == null) return;
+			
+			foreach (var feature in _features)
+			{
+				feature.OnPresenterClosed();
+			}
+		}
 	}
 
 	/// <inheritdoc cref="UiPresenter"/>
diff --git a/Runtime/UiService.cs b/Runtime/UiService.cs
index b4cb0f7..128bb0a 100644
--- a/Runtime/UiService.cs
+++ b/Runtime/UiService.cs
@@ -1,6 +1,8 @@
 using Cysharp.Threading.Tasks;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading;
 using UnityEngine;
 using UnityEngine.Events;
 using Object = UnityEngine.Object;
@@ -14,44 +16,86 @@ public class UiService : IUiServiceInit
 	{
 		public static readonly UnityEvent<DeviceOrientation, DeviceOrientation> OnOrientationChanged = new ();
 		public static readonly UnityEvent<Vector2, Vector2> OnResolutionChanged = new ();
+
+		/// <summary>
+		/// Internal static reference to the current analytics instance for editor tools only.
+		/// This is set when a UiService instance is created and cleared when disposed.
+		/// Only accessible to editor code within this package.
+		/// </summary>
+		internal static IUiAnalytics CurrentAnalytics { get; private set; }
 		
 		private readonly IUiAssetLoader _assetLoader;
+		private readonly IUiAnalytics _analytics;
 		private readonly IDictionary<Type, UiConfig> _uiConfigs = new Dictionary<Type, UiConfig>();
-		private readonly IList<Type> _visibleUiList = new List<Type>();
+		private readonly IList<UiInstanceId> _visibleUiList = new List<UiInstanceId>();
 		private readonly IDictionary<int, UiSetConfig> _uiSets = new Dictionary<int, UiSetConfig>();
-		private readonly IDictionary<int, GameObject> _layers = new Dictionary<int, GameObject>();
-		private readonly IDictionary<Type, UiPresenter> _uiPresenters = new Dictionary<Type, UiPresenter>();
+		private readonly IDictionary<Type, IList<UiInstance>> _uiPresenters = new Dictionary<Type, IList<UiInstance>>();
+
+		private readonly IReadOnlyDictionary<int, UiSetConfig> _uiSetsReadOnly;
+		private readonly IReadOnlyList<UiInstanceId> _visiblePresentersReadOnly;
 
-		private Type _loadingSpinnerType;
 		private Transform _uiParent;
+		private bool _disposed;
 
 		/// <inheritdoc />
-		public IReadOnlyDictionary<Type, UiPresenter> LoadedPresenters => new Dictionary<Type, UiPresenter>(_uiPresenters);
+		public IReadOnlyDictionary<int, UiSetConfig> UiSets => _uiSetsReadOnly;
 
 		/// <inheritdoc />
-		public IReadOnlyDictionary<int, GameObject> Layers => new Dictionary<int, GameObject>(_layers);
+		public IReadOnlyList<UiInstanceId> VisiblePresenters => _visiblePresentersReadOnly;
 
-		/// <inheritdoc />
-		public IReadOnlyDictionary<int, UiSetConfig> UiSets => new Dictionary<int, UiSetConfig>(_uiSets);
+		/// <summary>
+		/// Gets the analytics instance being used by this service
+		/// </summary>
+		public IUiAnalytics Analytics => _analytics;
 
-		/// <inheritdoc />
-		public IReadOnlyList<Type> VisiblePresenters => new List<Type>(_visibleUiList);
+		public UiService() : this(new UiAssetLoader(), null) { }
 
-		public UiService() : this(new UiAssetLoader()) { }
+		public UiService(IUiAssetLoader assetLoader) : this(assetLoader, null) { }
 
-		public UiService(IUiAssetLoader assetLoader)
+		public UiService(IUiAssetLoader assetLoader, IUiAnalytics analytics)
 		{
 			_assetLoader = assetLoader;
+			_analytics = analytics ?? new NullAnalytics();
+			
+			// Set static reference for editor/debugging access
+			CurrentAnalytics = _analytics;
+			
+			// Initialize readonly wrappers to avoid allocations on property access
+			_uiSetsReadOnly = new ReadOnlyDictionary<int, UiSetConfig>(_uiSets);
+			_visiblePresentersReadOnly = new ReadOnlyCollection<UiInstanceId>(_visibleUiList);
 		}
 
 		/// <inheritdoc />
 		public void Init(UiConfigs configs)
 		{
+			if (configs == null)
+			{
+				throw new ArgumentNullException(nameof(configs), "UiConfigs cannot be null");
+			}
+
 			var uiConfigs = configs.Configs;
 			var sets = configs.Sets;
 
 			foreach (var uiConfig in uiConfigs)
 			{
+				if (string.IsNullOrEmpty(uiConfig.AddressableAddress))
+				{
+					throw new ArgumentException($"UiConfig for type '{uiConfig.UiType.Name}' has empty addressable address. This UI will fail to load.");
+				}
+				if (uiConfig.UiType == null)
+				{
+					throw new ArgumentException($"UiConfig with addressable '{uiConfig.AddressableAddress}' has null UiType, skipping");
+				}
+
+				if (uiConfig.Layer < 0)
+				{
+					Debug.LogWarning($"UiConfig for type '{uiConfig.UiType.Name}' has negative layer number ({uiConfig.Layer}). This may cause unexpected behavior.");
+				}
+				if (uiConfig.Layer > 1000)
+				{
+					Debug.LogWarning($"UiConfig for type '{uiConfig.UiType.Name}' has very high layer number ({uiConfig.Layer}). Consider using lower values for better organization.");
+				}
+
 				AddUiConfig(uiConfig);
 			}
 
@@ -61,95 +105,184 @@ public void Init(UiConfigs configs)
 			}
 
 			_uiParent = new GameObject("Ui").transform;
-			_loadingSpinnerType = configs.LoadingSpinnerType;
 
 			_uiParent.gameObject.AddComponent<UiServiceMonoComponent>();
 			Object.DontDestroyOnLoad(_uiParent.gameObject);
+		}
 
-			if (_loadingSpinnerType != null)
+		/// <inheritdoc />
+		public List<UiInstance> GetLoadedPresenters()
+		{
+			var list = new List<UiInstance>();
+			
+			foreach (var kvp in _uiPresenters)
 			{
-				LoadUiAsync(_loadingSpinnerType).Forget();
+				list.AddRange(kvp.Value);
 			}
+			
+			return list;
 		}
 
 		/// <inheritdoc />
 		public T GetUi<T>() where T : UiPresenter
 		{
-			return _uiPresenters[typeof(T)] as T;
+			return GetUi<T>(ResolveInstanceAddress(typeof(T)));
+		}
+		
+		/// <summary>
+		/// Requests the UI of given type <typeparamref name="T"/> with the specified instance address
+		/// </summary>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <exception cref="KeyNotFoundException">
+		/// Thrown if the service does NOT contain an <see cref="UiPresenter"/> of the given type and instance address
+		/// </exception>
+		public T GetUi<T>(string instanceAddress) where T : UiPresenter
+		{
+			if (!TryFindPresenter(typeof(T), instanceAddress, out var presenter))
+			{
+				throw new KeyNotFoundException($"UI presenter of type {typeof(T).Name} with instance '{instanceAddress ?? "default"}' not found.");
+			}
+			return presenter as T;
 		}
 
 		/// <inheritdoc />
 		public bool IsVisible<T>() where T : UiPresenter
 		{
-			return _visibleUiList.Contains(typeof(T));
+			return IsVisible<T>(ResolveInstanceAddress(typeof(T)));
+		}
+		
+		/// <summary>
+		/// Requests the visible state of the given UI type <typeparamref name="T"/> with the specified instance address
+		/// </summary>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		public bool IsVisible<T>(string instanceAddress) where T : UiPresenter
+		{
+			var instanceId = new UiInstanceId(typeof(T), instanceAddress);
+			return _visibleUiList.Contains(instanceId);
 		}
 
 		/// <inheritdoc />
 		public void AddUiConfig(UiConfig config)
 		{
-			if (_uiConfigs.ContainsKey(config.UiType))
+			if (!_uiConfigs.TryAdd(config.UiType, config))
 			{
 				Debug.LogWarning($"The UiConfig {config.AddressableAddress} was already added");
-				return;
 			}
-
-			_uiConfigs.Add(config.UiType, config);
 		}
 
 		/// <inheritdoc />
 		public void AddUiSet(UiSetConfig uiSet)
 		{
-			if (_uiSets.ContainsKey(uiSet.SetId))
+			if (!_uiSets.TryAdd(uiSet.SetId, uiSet))
 			{
 				Debug.LogWarning($"The Ui Configuration with the id {uiSet.SetId.ToString()} was already added");
-				return;
 			}
-
-			_uiSets.Add(uiSet.SetId, uiSet);
 		}
 
 		/// <inheritdoc />
 		public void AddUi<T>(T ui, int layer, bool openAfter = false) where T : UiPresenter
+		{
+			AddUi(ui, layer, string.Empty, openAfter);
+		}
+		
+		/// <summary>
+		/// Adds a UI presenter to the service with an optional instance address
+		/// </summary>
+		/// <param name="ui">The UI presenter to add</param>
+		/// <param name="layer">The layer to include the UI presenter in</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <param name="openAfter">Whether to open the UI presenter after adding it</param>
+		public void AddUi<T>(T ui, int layer, string instanceAddress, bool openAfter = false) where T : UiPresenter
 		{
 			var type = ui.GetType().UnderlyingSystemType;
+			var instanceId = new UiInstanceId(type, instanceAddress);
 
-			if (_uiPresenters.ContainsKey(type))
+			// Check if already exists
+			if (TryFindPresenter(type, instanceAddress, out _))
 			{
-				Debug.LogWarning($"The Ui {type} was already added");
+				Debug.LogWarning($"The Ui {instanceId} was already added");
 				return;
 			}
+			
+			// Add to type-indexed collection
+			if (!_uiPresenters.TryGetValue(type, out var instanceList))
+			{
+				instanceList = new List<UiInstance>();
+				_uiPresenters[type] = instanceList;
+			}
+			instanceList.Add(new UiInstance(type, instanceAddress, ui));
+			
+			// Ensure Canvas sorting order matches layer
+			EnsureCanvasSortingOrder(ui.gameObject, layer);
 
-			_uiPresenters.Add(type, ui);
 			ui.Init(this);
 
 			if (openAfter)
 			{
-				OpenUi(type);
+				OpenUi(instanceId);
 			}
 		}
 
 		/// <inheritdoc />
 		public bool RemoveUi(Type type)
 		{
-			_visibleUiList.Remove(type);
+			return RemoveUi(type, ResolveInstanceAddress(type));
+		}
+		
+		/// <summary>
+		/// Removes the UI of the specified type and instance address from the service without unloading it
+		/// </summary>
+		/// <param name="type">The type of UI to remove</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <returns>True if the UI was removed, false otherwise</returns>
+		public bool RemoveUi(Type type, string instanceAddress)
+		{
+			var instanceId = new UiInstanceId(type, instanceAddress);
+			_visibleUiList.Remove(instanceId);
+			
+			if (!_uiPresenters.TryGetValue(type, out var instanceList))
+			{
+				return false;
+			}
+
+			// Find and remove the instance
+			for (int i = 0; i < instanceList.Count; i++)
+			{
+				if (instanceList[i].Address == instanceAddress)
+				{
+					instanceList.RemoveAt(i);
+					
+					// Clean up empty type entry
+					if (instanceList.Count == 0)
+					{
+						_uiPresenters.Remove(type);
+					}
+					
+					return true;
+				}
+			}
 			
-			return _uiPresenters.Remove(type);
+			return false;
 		}
 
 		/// <inheritdoc />
 		public List<UiPresenter> RemoveUiSet(int setId)
 		{
-			var set = _uiSets[setId];
+			if (!_uiSets.TryGetValue(setId, out var set))
+			{
+				throw new KeyNotFoundException($"UI Set with id {setId} not found.");
+			}
+			
 			var list = new List<UiPresenter>();
 
-			foreach (var type in set.UiConfigsType)
+			foreach (var instanceId in set.UiInstanceIds)
 			{
-				if (!_uiPresenters.TryGetValue(type, out var ui))
+				if (!TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out var ui))
 				{
 					continue;
 				}
 
-				RemoveUi(type);
+				RemoveUi(instanceId.PresenterType, instanceId.InstanceAddress);
 
 				list.Add(ui);
 			}
@@ -158,26 +291,43 @@ public List<UiPresenter> RemoveUiSet(int setId)
 		}
 
 		/// <inheritdoc />
-		public async UniTask<UiPresenter> LoadUiAsync(Type type, bool openAfter = false)
+		public async UniTask<UiPresenter> LoadUiAsync(Type type, bool openAfter = false, CancellationToken cancellationToken = default)
+		{
+			return await LoadUiAsync(type, ResolveInstanceAddress(type), openAfter, cancellationToken);
+		}
+		
+		/// <summary>
+		/// Loads the UI of the specified type asynchronously with an optional instance address
+		/// </summary>
+		/// <param name="type">The type of UI to load</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <param name="openAfter">Whether to open the UI after loading</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation</param>
+		/// <returns>A task that completes with the loaded UI</returns>
+		public async UniTask<UiPresenter> LoadUiAsync(Type type, string instanceAddress, bool openAfter = false, CancellationToken cancellationToken = default)
 		{
 			if (!_uiConfigs.TryGetValue(type, out var config))
 			{
 				throw new KeyNotFoundException($"The UiConfig of type {type} was not added to the service. Call {nameof(AddUiConfig)} first");
 			}
 
-			if (_uiPresenters.TryGetValue(type, out var ui))
+			var instanceId = new UiInstanceId(type, instanceAddress);
+			
+			if (TryFindPresenter(type, instanceAddress, out var existingUi))
 			{
-				Debug.LogWarning($"The Ui {type} was already loaded");
-				ui.gameObject.SetActive(openAfter);
+				Debug.LogWarning($"The Ui {instanceId} was already loaded");
+				existingUi.gameObject.SetActive(openAfter);
 
-				return ui;
+				return existingUi;
 			}
 
-			var layer = AddLayer(config.Layer);
-			var gameObject = await _assetLoader.InstantiatePrefab(config, layer.transform);
+			_analytics.TrackLoadStart(type);
+
+			// Parent directly to _uiParent - no layer GameObjects needed
+			var gameObject = await _assetLoader.InstantiatePrefab(config, _uiParent, cancellationToken);
 
 			// Double check if the same UiPresenter was already loaded. This can happen if the coder spam calls LoadUiAsync
-			if (_uiPresenters.TryGetValue(type, out var uiDouble))
+			if (TryFindPresenter(type, instanceAddress, out var uiDouble))
 			{
 				_assetLoader.UnloadAsset(gameObject);
 				uiDouble.gameObject.SetActive(openAfter);
@@ -188,7 +338,9 @@ public async UniTask<UiPresenter> LoadUiAsync(Type type, bool openAfter = false)
 			var uiPresenter = gameObject.GetComponent<UiPresenter>();
 
 			gameObject.SetActive(false);
-			AddUi(uiPresenter, config.Layer, openAfter);
+			AddUi(uiPresenter, config.Layer, instanceAddress, openAfter);
+			
+			_analytics.TrackLoadComplete(type, config.Layer);
 
 			return uiPresenter;
 		}
@@ -200,14 +352,14 @@ public IList<UniTask<UiPresenter>> LoadUiSetAsync(int setId)
 
 			if (_uiSets.TryGetValue(setId, out var set))
 			{
-				foreach (var type in set.UiConfigsType)
+				foreach (var instanceId in set.UiInstanceIds)
 				{
-					if (_uiPresenters.ContainsKey(type))
+					if (TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out _))
 					{
 						continue;
 					}
 
-					uiTasks.Add(LoadUiAsync(type));
+					uiTasks.Add(LoadUiAsync(instanceId.PresenterType, instanceId.InstanceAddress));
 				}
 			}
 
@@ -217,11 +369,30 @@ public IList<UniTask<UiPresenter>> LoadUiSetAsync(int setId)
 		/// <inheritdoc />
 		public void UnloadUi(Type type)
 		{
-			var ui = _uiPresenters[type];
-
-			RemoveUi(type);
+			UnloadUi(type, ResolveInstanceAddress(type));
+		}
+		
+		/// <summary>
+		/// Unloads the UI of the specified type and instance address
+		/// </summary>
+		/// <param name="type">The type of UI to unload</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		public void UnloadUi(Type type, string instanceAddress)
+		{
+			var instanceId = new UiInstanceId(type, instanceAddress);
+			
+			if (!TryFindPresenter(type, instanceAddress, out var ui))
+			{
+				throw new KeyNotFoundException($"Cannot unload UI {instanceId}. It is not loaded.");
+			}
+			
+			var config = _uiConfigs[type];
+			
+			RemoveUi(type, instanceAddress);
 
 			_assetLoader.UnloadAsset(ui.gameObject);
+			
+			_analytics.TrackUnload(type, config.Layer);
 		}
 
 		/// <inheritdoc />
@@ -229,50 +400,65 @@ public void UnloadUiSet(int setId)
 		{
 			var set = _uiSets[setId];
 
-			foreach (var type in set.UiConfigsType)
+			foreach (var instanceId in set.UiInstanceIds)
 			{
-				if (_uiPresenters.ContainsKey(type))
+				if (TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out _))
 				{
-					UnloadUi(type);
+					UnloadUi(instanceId.PresenterType, instanceId.InstanceAddress);
 				}
 			}
 		}
 
 		/// <inheritdoc />
-		public async UniTask<UiPresenter> OpenUiAsync(Type type)
+		public async UniTask<UiPresenter> OpenUiAsync(Type type, CancellationToken cancellationToken = default)
+		{
+			return await OpenUiAsync(type, ResolveInstanceAddress(type), cancellationToken);
+		}
+		
+		/// <summary>
+		/// Opens a UI presenter asynchronously with an optional instance address
+		/// </summary>
+		/// <param name="type">The type of UI presenter to open</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation</param>
+		public async UniTask<UiPresenter> OpenUiAsync(Type type, string instanceAddress, CancellationToken cancellationToken = default)
 		{
-			var ui = await GetOrLoadUiAsync(type);
+			var ui = await GetOrLoadUiAsync(type, instanceAddress, cancellationToken);
 
-			OpenUi(type);
+			OpenUi(new UiInstanceId(type, instanceAddress));
 
 			return ui;
 		}
 
 		/// <inheritdoc />
-		public async UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialData) where TData : struct
+		public async UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialData, CancellationToken cancellationToken = default) where TData : struct
 		{
-			var ui = await GetOrLoadUiAsync(type);
+			return await OpenUiAsync(type, ResolveInstanceAddress(type), initialData, cancellationToken);
+		}
+		
+		/// <summary>
+		/// Opens a UI presenter asynchronously with initial data and an optional instance address
+		/// </summary>
+		/// <param name="type">The type of UI presenter to open</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <param name="initialData">The initial data to set</param>
+		/// <param name="cancellationToken">Cancellation token to cancel the operation</param>
+		public async UniTask<UiPresenter> OpenUiAsync<TData>(Type type, string instanceAddress, TData initialData, CancellationToken cancellationToken = default) where TData : struct
+		{
+			var ui = await GetOrLoadUiAsync(type, instanceAddress, cancellationToken);
 
-			if (ui is UiToolkitPresenter<TData>)
+			if (ui is UiPresenter<TData> uiPresenter)
 			{
-				var uiPresenter = ui as UiToolkitPresenter<TData>;
-				
-				uiPresenter.InternalSetData(initialData);
-			}
-			else if (ui is UiPresenter<TData>)
-			{
-				var uiPresenter = ui as UiPresenter<TData>;
-				
 				uiPresenter.InternalSetData(initialData);
 			}
 			else
 			{
-				Debug.LogError($"The UiPresenter {type} is not a {nameof(UiPresenter<TData>)} nor {nameof(UiToolkitPresenter<TData>)} type. " +
-				               $"Implement it to allow it to open with initial defined data");
+				Debug.LogError($"The UiPresenter {type} is not a {nameof(UiPresenter<TData>)} type. " +
+							$"Implement UiPresenter<{typeof(TData).Name}> to allow it to open with initial defined data");
 				return ui;
 			}
 			
-			OpenUi(type);
+			OpenUi(new UiInstanceId(type, instanceAddress));
 
 			return ui;
 		}
@@ -280,23 +466,47 @@ public async UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialDat
 		/// <inheritdoc />
 		public void CloseUi(Type type, bool destroy = false)
 		{
-			if (!_visibleUiList.Contains(type))
+			CloseUi(type, ResolveInstanceAddress(type), destroy);
+		}
+		
+		/// <summary>
+		/// Closes a UI presenter with an optional instance address and optionally destroys its assets
+		/// </summary>
+		/// <param name="type">The type of UI presenter to close</param>
+		/// <param name="instanceAddress">Optional instance address. Use null for default/singleton instance.</param>
+		/// <param name="destroy">Whether to destroy the UI presenter's assets</param>
+		public void CloseUi(Type type, string instanceAddress, bool destroy = false)
+		{
+			var instanceId = new UiInstanceId(type, instanceAddress);
+			
+			if (!_visibleUiList.Contains(instanceId))
 			{
-				Debug.LogWarning($"Is trying to close the {type.Name} ui but is not open");
+				Debug.LogWarning($"Is trying to close the {instanceId} ui but is not open");
 				return;
 			}
 
-			_visibleUiList.Remove(type);
-			_uiPresenters[type].InternalClose(destroy);
+			_analytics.TrackCloseStart(type);
+			
+			_visibleUiList.Remove(instanceId);
+			
+			if (TryFindPresenter(type, instanceAddress, out var presenter))
+			{
+				presenter.InternalClose(destroy);
+				
+				var config = _uiConfigs[type];
+				_analytics.TrackCloseComplete(type, config.Layer, destroy);
+			}
 		}
 
 		/// <inheritdoc />
 		public void CloseAllUi()
 		{
-			for (int i = 0; i < _visibleUiList.Count; i++)
+			foreach (var instanceId in _visibleUiList)
 			{
-				_uiPresenters[_visibleUiList[i]].InternalClose(false);
-				_visibleUiList.Remove(_visibleUiList[i]);
+				if (TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out var presenter))
+				{
+					presenter.InternalClose(false);
+				}
 			}
 
 			_visibleUiList.Clear();
@@ -307,12 +517,15 @@ public void CloseAllUi(int layer)
 		{
 			for (int i = _visibleUiList.Count - 1; i >= 0; i--)
 			{
-				var type = _visibleUiList[i];
+				var instanceId = _visibleUiList[i];
 
-				if (_uiConfigs[type].Layer == layer)
+				if (_uiConfigs[instanceId.PresenterType].Layer == layer)
 				{
-					_uiPresenters[type].InternalClose(false);
-					_visibleUiList.Remove(type);
+					if (TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out var presenter))
+					{
+						presenter.InternalClose(false);
+					}
+					_visibleUiList.Remove(instanceId);
 				}
 			}
 		}
@@ -322,68 +535,175 @@ public void CloseAllUiSet(int setId)
 		{
 			var set = _uiSets[setId];
 
-			foreach (var type in set.UiConfigsType)
+			foreach (var instanceId in set.UiInstanceIds)
 			{
-				CloseUi(type);
+				CloseUi(instanceId.PresenterType, instanceId.InstanceAddress);
 			}
 		}
 
-		private GameObject AddLayer(int layer)
+		/// <summary>
+		/// Disposes of the UI service, cleaning up all resources and unsubscribing from events.
+		/// </summary>
+		public void Dispose()
 		{
-			if (_layers.ContainsKey(layer)) return _layers[layer];
+			if (_disposed)
+			{
+				return;
+			}
 
-			var newObj = new GameObject($"Layer {layer.ToString()}");
+			_disposed = true;
+
+			// Clear static reference
+			if (CurrentAnalytics == _analytics)
+			{
+				CurrentAnalytics = null;
+			}
+
+			// Close all visible UI
+			CloseAllUi();
+
+			// Unload all UI presenters
+			var presenterInstances = new List<UiInstanceId>();
+			foreach (var kvp in _uiPresenters)
+			{
+				var type = kvp.Key;
+				foreach (var instance in kvp.Value)
+				{
+					presenterInstances.Add(new UiInstanceId(type, instance.Address));
+				}
+			}
+			
+			foreach (var instanceId in presenterInstances)
+			{
+				try
+				{
+					UnloadUi(instanceId.PresenterType, instanceId.InstanceAddress);
+				}
+				catch (Exception ex)
+				{
+					Debug.LogWarning($"Failed to unload UI {instanceId} during disposal: {ex.Message}");
+				}
+			}
 
-			newObj.transform.position = Vector3.zero;
+			// Clear all collections
+			_uiPresenters.Clear();
+			_visibleUiList.Clear();
+			_uiConfigs.Clear();
+			_uiSets.Clear();
 
-			newObj.transform.SetParent(_uiParent);
-			_layers.Add(layer, newObj);
+			// Clean up static events
+			// Note: We don't call RemoveAllListeners on static UnityEvents as it would affect other instances
+			// Users should unsubscribe from OnOrientationChanged and OnResolutionChanged in their own code
 
-			return _layers[layer];
+			// Destroy UI parent GameObject
+			if (_uiParent != null)
+			{
+				Object.Destroy(_uiParent.gameObject);
+				_uiParent = null;
+			}
 		}
 
-		private void OpenUi(Type type)
+		/// <summary>
+		/// Attempts to find a presenter by type and address
+		/// </summary>
+		/// <param name="type">The type of UI presenter to find</param>
+		/// <param name="address">The instance address</param>
+		/// <param name="presenter">The found presenter, or null if not found</param>
+		/// <returns>True if the presenter was found, false otherwise</returns>
+		private bool TryFindPresenter(Type type, string address, out UiPresenter presenter)
 		{
-			if (_visibleUiList.Contains(type))
+			if (_uiPresenters.TryGetValue(type, out var instances))
 			{
-				Debug.LogWarning($"Is trying to open the {type.Name} ui but is already open");
-				return;
+				foreach (var instance in instances)
+				{
+					if (instance.Address == address)
+					{
+						presenter = instance.Presenter;
+						return true;
+					}
+				}
 			}
 
-			_uiPresenters[type].InternalOpen();
-			_visibleUiList.Add(type);
+			presenter = null;
+			return false;
 		}
 
-		private async UniTask<UiPresenter> GetOrLoadUiAsync(Type type)
+		private void EnsureCanvasSortingOrder(GameObject gameObject, int layer)
 		{
-			if (!_uiPresenters.TryGetValue(type, out var ui))
+			if (gameObject.TryGetComponent<Canvas>(out var canvas))
 			{
-				OpenLoadingSpinner();
-				await LoadUiAsync(type);
-				CloseLoadingSpinner();
+				canvas.sortingOrder = layer;
+			}
+			else if (gameObject.TryGetComponent<UnityEngine.UIElements.UIDocument>(out var document))
+			{
+				document.sortingOrder = layer;
 			}
-
-			return ui;
 		}
 
-		private void OpenLoadingSpinner()
+		private void OpenUi(UiInstanceId instanceId)
 		{
-			if (_loadingSpinnerType == null)
+			if (_visibleUiList.Contains(instanceId))
 			{
+				Debug.LogWarning($"Is trying to open the {instanceId} ui but is already open");
 				return;
 			}
 
-			OpenUi(_loadingSpinnerType);
+			_analytics.TrackOpenStart(instanceId.PresenterType);
+			
+			if (TryFindPresenter(instanceId.PresenterType, instanceId.InstanceAddress, out var presenter))
+			{
+				presenter.InternalOpen();
+				_visibleUiList.Add(instanceId);
+				
+				var config = _uiConfigs[instanceId.PresenterType];
+				_analytics.TrackOpenComplete(instanceId.PresenterType, config.Layer);
+			}
 		}
 
-		private void CloseLoadingSpinner()
+		private async UniTask<UiPresenter> GetOrLoadUiAsync(Type type, string instanceAddress, CancellationToken cancellationToken = default)
 		{
-			if (_loadingSpinnerType == null)
+			if (!TryFindPresenter(type, instanceAddress, out var ui))
 			{
-				return;
+				ui = await LoadUiAsync(type, instanceAddress, false, cancellationToken);
 			}
 
-			CloseUi(_loadingSpinnerType);
+			return ui;
+		}
+
+		/// <summary>
+		/// Resolves the instance address for a given type when no specific instance is requested.
+		/// If only one instance of the type exists, returns that instance's address.
+		/// If multiple instances exist, returns the first one found and logs a warning.
+		/// If no instances exist, returns string.Empty (default).
+		/// </summary>
+		/// <param name="type">The type of UI presenter to resolve</param>
+		/// <returns>The resolved instance address</returns>
+		private string ResolveInstanceAddress(Type type)
+		{
+			if (!_uiPresenters.TryGetValue(type, out var instances))
+			{
+				// No instances found, return default (string.Empty)
+				return string.Empty;
+			}
+			
+			if (instances.Count == 1)
+			{
+				return instances[0].Address;
+			}
+			
+			// Multiple instances found - log warning and return the first
+			var instanceNames = new List<string>(instances.Count);
+			foreach (var instance in instances)
+			{
+				instanceNames.Add(string.IsNullOrEmpty(instance.Address) ? "default" : instance.Address);
+			}
+			
+			var firstMatch = instances[0];
+			var selectedName = string.IsNullOrEmpty(firstMatch.Address) ? "default" : firstMatch.Address;
+			Debug.LogWarning($"[UiService] Ambiguous call for {type.Name}: found {instances.Count} instances [{string.Join(", ", instanceNames)}]. " +
+							$"Using '{selectedName}'. Specify instance address explicitly to avoid ambiguity.");
+			
+			return firstMatch.Address;
 		}
 	}
 }
\ No newline at end of file
diff --git a/Runtime/UiSetConfig.cs b/Runtime/UiSetConfig.cs
index 2ee4a40..e955990 100644
--- a/Runtime/UiSetConfig.cs
+++ b/Runtime/UiSetConfig.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using UnityEngine;
 
 // ReSharper disable CheckNamespace
 
@@ -8,11 +9,107 @@ namespace GameLovers.UiService
 	/// <summary>
 	/// Represents a configuration set of UIs that can be managed together in the <seealso cref="UiService"/>
 	/// This can be helpful for a UI combo set that are always visible together (ex: player Hud with currency & settings)
+	/// Supports multiple instances of the same UI type via UiInstanceId
 	/// </summary>
 	[Serializable]
 	public struct UiSetConfig
 	{
 		public int SetId;
-		public IReadOnlyList<Type> UiConfigsType;
+		public UiInstanceId[] UiInstanceIds;
+	}
+
+	/// <summary>
+	/// Serializable entry for a UI instance in a set.
+	/// Stores Type as string and optional instance address.
+	/// This is more robust than storing addressable addresses which can change.
+	/// </summary>
+	[Serializable]
+	public struct UiSetEntry
+	{
+		/// <summary>
+		/// The AssemblyQualifiedName of the UI presenter type
+		/// </summary>
+		public string UiTypeName;
+		
+		/// <summary>
+		/// Optional instance address for multi-instance support. Empty string means default instance.
+		/// </summary>
+		public string InstanceAddress;
+		
+		public UiInstanceId ToUiInstanceId()
+		{
+			var type = Type.GetType(UiTypeName);
+			if (type == null)
+			{
+				Debug.LogWarning($"Could not find type: {UiTypeName}");
+				return default;
+			}
+			return new UiInstanceId(type, string.IsNullOrEmpty(InstanceAddress) ? null : InstanceAddress);
+		}
+		
+		public static UiSetEntry FromUiInstanceId(UiInstanceId instanceId)
+		{
+			return new UiSetEntry
+			{
+				UiTypeName = instanceId.PresenterType.AssemblyQualifiedName,
+				InstanceAddress = instanceId.InstanceAddress ?? string.Empty
+			};
+		}
+	}
+
+	/// <summary>
+	/// Necessary to serialize the data in scriptable object.
+	/// Now stores Type names instead of addressable addresses for robustness.
+	/// </summary>
+	[Serializable]
+	public struct UiSetConfigSerializable
+	{
+		public int SetId;
+		public List<UiSetEntry> UiEntries;
+
+		public static UiSetConfig ToUiSetConfig(UiSetConfigSerializable serializable)
+		{
+			var instanceIds = new List<UiInstanceId>();
+			
+			if (serializable.UiEntries != null)
+			{
+				foreach (var entry in serializable.UiEntries)
+				{
+					var instanceId = entry.ToUiInstanceId();
+					if (instanceId.PresenterType != null)
+					{
+						instanceIds.Add(instanceId);
+					}
+				}
+			}
+			
+			return new UiSetConfig 
+			{ 
+				SetId = serializable.SetId, 
+				UiInstanceIds = instanceIds.ToArray()
+			};
+		}
+
+		public static UiSetConfigSerializable FromUiSetConfig(UiSetConfig config)
+		{
+			var entries = new List<UiSetEntry>();
+			
+			if (config.UiInstanceIds != null)
+			{
+				foreach (var instanceId in config.UiInstanceIds)
+				{
+					if (instanceId.PresenterType != null)
+					{
+						entries.Add(UiSetEntry.FromUiInstanceId(instanceId));
+					}
+				}
+			}
+			
+			return new UiSetConfigSerializable 
+			{ 
+				SetId = config.SetId, 
+				UiEntries = entries 
+			};
+		}
 	}
 }
\ No newline at end of file
diff --git a/Runtime/UiToolkitPresenter.cs b/Runtime/UiToolkitPresenter.cs
deleted file mode 100644
index 9540770..0000000
--- a/Runtime/UiToolkitPresenter.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-using UnityEngine;
-using UnityEngine.UIElements;
-
-namespace GameLovers.UiService
-{
-	/// /// <summary>
-	/// Tags the <see cref="UiToolkitPresenter"/> as a <see cref="UiToolkitPresenterData{T}"/> to allow defining a
-	/// specific state when opening the UI via the <see cref="UiService"/>
-	public interface IUiToolkitPresenterData : IUiPresenterData
-	{
-	}
-
-	/// <summary>
-	/// Base presenter for UI Toolkit-based views. Ensures a <see cref="UIDocument"/> is present
-	/// and provides derived presenters access to it.
-	/// </summary>
-	[RequireComponent(typeof(UIDocument))]
-	public abstract class UiToolkitPresenter : UiPresenter
-	{
-		[SerializeField] private UIDocument _document;
-
-		/// <summary>
-		/// Provides access to the attached <see cref="UIDocument"/> for derived presenters.
-		/// </summary>
-		protected UIDocument Document => _document;
-		
-		/// <summary>
-		/// The root element of the <see cref="UIDocument"/> defining this presenter
-		/// </summary>
-		protected VisualElement Root => _document.rootVisualElement;
-
-		/// <summary>
-		/// Assigns the serialized <see cref="UIDocument"/> reference from the component on this GameObject.
-		/// </summary>
-		protected virtual void OnValidate()
-		{
-			_document = _document == null ? GetComponent<UIDocument>() : _document;
-		}
-	}
-	
-	/// <inheritdoc cref="UiToolkitPresenter"/>
-	/// <remarks>
-	/// Extends the <see cref="UiToolkitPresenter"/> behaviour to hold data of type <typeparamref name="T"/>
-	/// </remarks>
-	public abstract class UiToolkitPresenter<T> : UiToolkitPresenter, IUiToolkitPresenterData where T : struct
-	{
-		/// <summary>
-		/// The Ui data defined when opened via the <see cref="UiService"/>
-		/// </summary>
-		public T Data { get; protected set; }
-
-		/// <summary>
-		/// Allows the ui presenter implementation to have extra behaviour when the data defined for the presenter is set
-		/// </summary>
-		protected virtual void OnSetData() {}
-
-		internal void InternalSetData(T data)
-		{
-			Data = data;
-
-			OnSetData();
-		}
-	}
-}
-
diff --git a/Runtime/UiToolkitPresenter.cs.meta b/Runtime/UiToolkitPresenter.cs.meta
deleted file mode 100644
index 7a13e88..0000000
--- a/Runtime/UiToolkitPresenter.cs.meta
+++ /dev/null
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: d6d1d1498b5894a0183d766cf3ae8724
\ No newline at end of file
diff --git a/Samples~/Analytics/AnalyticsCallbackExample.cs b/Samples~/Analytics/AnalyticsCallbackExample.cs
new file mode 100644
index 0000000..b3b9111
--- /dev/null
+++ b/Samples~/Analytics/AnalyticsCallbackExample.cs
@@ -0,0 +1,192 @@
+using UnityEngine;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example implementation of custom analytics callback
+	/// This demonstrates how to integrate with external analytics services
+	/// </summary>
+	public class CustomAnalyticsCallback : IUiAnalyticsCallback
+	{
+		public void OnUiLoaded(UiEventData data)
+		{
+			Debug.Log($"[CustomAnalytics] UI Loaded: {data.UiName} on layer {data.Layer} at {data.Timestamp}s");
+			
+			// Example: Send to your analytics service
+			// AnalyticsService.TrackEvent("ui_loaded", new {
+			//     ui_name = data.UiName,
+			//     layer = data.Layer,
+			//     timestamp = data.Timestamp
+			// });
+		}
+
+		public void OnUiOpened(UiEventData data)
+		{
+			Debug.Log($"[CustomAnalytics] UI Opened: {data.UiName} on layer {data.Layer}");
+			
+			// Example: Send to your analytics service
+			// AnalyticsService.TrackEvent("ui_opened", new {
+			//     ui_name = data.UiName,
+			//     layer = data.Layer
+			// });
+		}
+
+		public void OnUiClosed(UiEventData data)
+		{
+			Debug.Log($"[CustomAnalytics] UI Closed: {data.UiName} (destroyed: {data.WasDestroyed})");
+			
+			// Example: Send to your analytics service
+			// AnalyticsService.TrackEvent("ui_closed", new {
+			//     ui_name = data.UiName,
+			//     was_destroyed = data.WasDestroyed
+			// });
+		}
+
+		public void OnUiUnloaded(UiEventData data)
+		{
+			Debug.Log($"[CustomAnalytics] UI Unloaded: {data.UiName}");
+			
+			// Example: Send to your analytics service
+			// AnalyticsService.TrackEvent("ui_unloaded", new {
+			//     ui_name = data.UiName
+			// });
+		}
+
+		public void OnPerformanceMetricsUpdated(UiPerformanceMetrics metrics)
+		{
+			Debug.Log($"[CustomAnalytics] Performance Updated: {metrics.UiName} - " +
+					  $"Load: {metrics.LoadDuration:F3}s, Open: {metrics.OpenDuration:F3}s, " +
+					  $"Close: {metrics.CloseDuration:F3}s");
+			
+			// Example: Send performance metrics to your analytics service
+			// AnalyticsService.TrackPerformance("ui_performance", new {
+			//     ui_name = metrics.UiName,
+			//     load_duration = metrics.LoadDuration,
+			//     open_duration = metrics.OpenDuration,
+			//     close_duration = metrics.CloseDuration
+			// });
+		}
+	}
+
+	/// <summary>
+	/// Example demonstrating UI analytics integration
+	/// </summary>
+	public class AnalyticsExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+		
+		private IUiService _uiService;
+		private CustomAnalyticsCallback _analyticsCallback;
+
+		private void Start()
+		{
+			// Initialize analytics callback
+			_analyticsCallback = new CustomAnalyticsCallback();
+			UiAnalytics.SetCallback(_analyticsCallback);
+			
+			// Enable analytics (enabled by default)
+			UiAnalytics.IsEnabled = true;
+			
+			// Subscribe to analytics events
+			SubscribeToAnalyticsEvents();
+			
+			// Initialize UI Service
+			_uiService = new UiService();
+			_uiService.Init(_uiConfigs);
+			
+			Debug.Log("=== Analytics Example Started ===");
+			Debug.Log("Press 1: Load UI (track load time)");
+			Debug.Log("Press 2: Open UI (track open time)");
+			Debug.Log("Press 3: Close UI (track close time)");
+			Debug.Log("Press 4: View Performance Summary");
+			Debug.Log("Press 5: Clear Analytics Data");
+		}
+
+		private void OnDestroy()
+		{
+			// Unsubscribe from events
+			UnsubscribeFromAnalyticsEvents();
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				Debug.Log("Loading UI with analytics tracking...");
+				_uiService.LoadUi<BasicUiExamplePresenter>();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				Debug.Log("Opening UI with analytics tracking...");
+				_uiService.OpenUi<BasicUiExamplePresenter>();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha3))
+			{
+				Debug.Log("Closing UI with analytics tracking...");
+				_uiService.CloseUi<BasicUiExamplePresenter>(destroy: false);
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha4))
+			{
+				Debug.Log("Displaying performance summary...");
+				UiAnalytics.LogPerformanceSummary();
+				
+				// Get specific metrics
+				var metrics = UiAnalytics.GetMetrics(typeof(BasicUiExamplePresenter));
+				Debug.Log($"\nDetailed metrics for BasicUiExamplePresenter:");
+				Debug.Log($"  Opens: {metrics.OpenCount}, Closes: {metrics.CloseCount}");
+				Debug.Log($"  Lifetime: {metrics.TotalLifetime:F1}s");
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha5))
+			{
+				Debug.Log("Clearing all analytics data...");
+				UiAnalytics.Clear();
+			}
+		}
+
+		private void SubscribeToAnalyticsEvents()
+		{
+			UiAnalytics.OnUiLoaded.AddListener(OnUiLoadedEvent);
+			UiAnalytics.OnUiOpened.AddListener(OnUiOpenedEvent);
+			UiAnalytics.OnUiClosed.AddListener(OnUiClosedEvent);
+			UiAnalytics.OnUiUnloaded.AddListener(OnUiUnloadedEvent);
+			UiAnalytics.OnPerformanceMetricsUpdated.AddListener(OnPerformanceUpdatedEvent);
+		}
+
+		private void UnsubscribeFromAnalyticsEvents()
+		{
+			UiAnalytics.OnUiLoaded.RemoveListener(OnUiLoadedEvent);
+			UiAnalytics.OnUiOpened.RemoveListener(OnUiOpenedEvent);
+			UiAnalytics.OnUiClosed.RemoveListener(OnUiClosedEvent);
+			UiAnalytics.OnUiUnloaded.RemoveListener(OnUiUnloadedEvent);
+			UiAnalytics.OnPerformanceMetricsUpdated.RemoveListener(OnPerformanceUpdatedEvent);
+		}
+
+		private void OnUiLoadedEvent(UiEventData data)
+		{
+			Debug.Log($"[Event] UI Loaded: {data.UiName}");
+		}
+
+		private void OnUiOpenedEvent(UiEventData data)
+		{
+			Debug.Log($"[Event] UI Opened: {data.UiName}");
+		}
+
+		private void OnUiClosedEvent(UiEventData data)
+		{
+			Debug.Log($"[Event] UI Closed: {data.UiName}");
+		}
+
+		private void OnUiUnloadedEvent(UiEventData data)
+		{
+			Debug.Log($"[Event] UI Unloaded: {data.UiName}");
+		}
+
+		private void OnPerformanceUpdatedEvent(UiPerformanceMetrics metrics)
+		{
+			// This fires frequently, so we don't log every update
+			// Debug.Log($"[Event] Performance Updated: {metrics.UiName}");
+		}
+	}
+}
+
diff --git a/Samples~/BasicUiFlow/BasicUiExamplePresenter.cs b/Samples~/BasicUiFlow/BasicUiExamplePresenter.cs
new file mode 100644
index 0000000..2797ce0
--- /dev/null
+++ b/Samples~/BasicUiFlow/BasicUiExamplePresenter.cs
@@ -0,0 +1,44 @@
+using UnityEngine;
+using UnityEngine.UI;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example UI Presenter demonstrating basic UI lifecycle
+	/// </summary>
+	public class BasicUiExamplePresenter : UiPresenter
+	{
+		[SerializeField] private Text _titleText;
+		[SerializeField] private Button _closeButton;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			Debug.Log("[BasicUiExample] UI Initialized");
+			
+			if (_closeButton != null)
+			{
+				_closeButton.onClick.AddListener(() => Close(destroy: false));
+			}
+		}
+
+		protected override void OnOpened()
+		{
+			base.OnOpened();
+			Debug.Log("[BasicUiExample] UI Opened");
+			
+			if (_titleText != null)
+			{
+				_titleText.text = "Basic UI Example";
+			}
+		}
+
+		protected override void OnClosed()
+		{
+			base.OnClosed();
+			Debug.Log("[BasicUiExample] UI Closed");
+		}
+	}
+}
+
diff --git a/Samples~/BasicUiFlow/BasicUiFlowExample.cs b/Samples~/BasicUiFlow/BasicUiFlowExample.cs
new file mode 100644
index 0000000..96684c2
--- /dev/null
+++ b/Samples~/BasicUiFlow/BasicUiFlowExample.cs
@@ -0,0 +1,64 @@
+using UnityEngine;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example demonstrating basic UI flow: loading, opening, closing, unloading
+	/// </summary>
+	public class BasicUiFlowExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+		
+		private IUiService _uiService;
+
+		private void Start()
+		{
+			// Initialize UI Service
+			_uiService = new UiService();
+			_uiService.Init(_uiConfigs);
+			
+			Debug.Log("=== Basic UI Flow Example Started ===");
+			Debug.Log("Press 1: Load UI");
+			Debug.Log("Press 2: Open UI");
+			Debug.Log("Press 3: Close UI (keep in memory)");
+			Debug.Log("Press 4: Unload UI (destroy)");
+			Debug.Log("Press 5: Load & Open (combined)");
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				Debug.Log("Loading BasicUiExamplePresenter...");
+				_uiService.LoadUi<BasicUiExamplePresenter>();
+				Debug.Log("UI Loaded (but not visible yet)");
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				Debug.Log("Opening BasicUiExamplePresenter...");
+				_uiService.OpenUi<BasicUiExamplePresenter>();
+				Debug.Log("UI Opened and visible");
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha3))
+			{
+				Debug.Log("Closing BasicUiExamplePresenter (destroy: false)...");
+				_uiService.CloseUi<BasicUiExamplePresenter>(destroy: false);
+				Debug.Log("UI Closed but still in memory");
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha4))
+			{
+				Debug.Log("Unloading BasicUiExamplePresenter...");
+				_uiService.UnloadUi<BasicUiExamplePresenter>();
+				Debug.Log("UI Destroyed and removed from memory");
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha5))
+			{
+				Debug.Log("Loading and Opening BasicUiExamplePresenter (combined)...");
+				_uiService.LoadUi<BasicUiExamplePresenter>(openAfter: true);
+				Debug.Log("UI Loaded and Opened in one call");
+			}
+		}
+	}
+}
+
diff --git a/Samples~/DataPresenter/DataPresenterExample.cs b/Samples~/DataPresenter/DataPresenterExample.cs
new file mode 100644
index 0000000..6063fc9
--- /dev/null
+++ b/Samples~/DataPresenter/DataPresenterExample.cs
@@ -0,0 +1,105 @@
+using UnityEngine;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example demonstrating data-driven UI presenters
+	/// </summary>
+	public class DataPresenterExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+		
+		private IUiService _uiService;
+
+		private void Start()
+		{
+			// Initialize UI Service
+			_uiService = new UiService();
+			_uiService.Init(_uiConfigs);
+			
+			Debug.Log("=== Data Presenter Example Started ===");
+			Debug.Log("Press 1: Show Warrior Data");
+			Debug.Log("Press 2: Show Mage Data");
+			Debug.Log("Press 3: Show Rogue Data");
+			Debug.Log("Press 4: Update to Low Health");
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				ShowWarriorData();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				ShowMageData();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha3))
+			{
+				ShowRogueData();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha4))
+			{
+				UpdateToLowHealth();
+			}
+		}
+
+		private void ShowWarriorData()
+		{
+			var data = new PlayerData
+			{
+				PlayerName = "Thor the Warrior",
+				Level = 45,
+				Score = 12500,
+				HealthPercentage = 0.85f
+			};
+			
+			Debug.Log("Opening UI with Warrior data...");
+			_uiService.OpenUi<DataUiExamplePresenter, PlayerData>(data);
+		}
+
+		private void ShowMageData()
+		{
+			var data = new PlayerData
+			{
+				PlayerName = "Gandalf the Mage",
+				Level = 99,
+				Score = 50000,
+				HealthPercentage = 0.60f
+			};
+			
+			Debug.Log("Opening UI with Mage data...");
+			_uiService.OpenUi<DataUiExamplePresenter, PlayerData>(data);
+		}
+
+		private void ShowRogueData()
+		{
+			var data = new PlayerData
+			{
+				PlayerName = "Shadow the Rogue",
+				Level = 33,
+				Score = 8900,
+				HealthPercentage = 1.0f
+			};
+			
+			Debug.Log("Opening UI with Rogue data...");
+			_uiService.OpenUi<DataUiExamplePresenter, PlayerData>(data);
+		}
+
+		private void UpdateToLowHealth()
+		{
+			var data = new PlayerData
+			{
+				PlayerName = "Wounded Hero",
+				Level = 15,
+				Score = 3500,
+				HealthPercentage = 0.15f
+			};
+			
+			Debug.Log("Updating to low health data...");
+			_uiService.OpenUi<DataUiExamplePresenter, PlayerData>(data);
+		}
+	}
+}
+
diff --git a/Samples~/DataPresenter/DataUiExamplePresenter.cs b/Samples~/DataPresenter/DataUiExamplePresenter.cs
new file mode 100644
index 0000000..6b87915
--- /dev/null
+++ b/Samples~/DataPresenter/DataUiExamplePresenter.cs
@@ -0,0 +1,78 @@
+using UnityEngine;
+using UnityEngine.UI;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example data structure for UI Presenter
+	/// </summary>
+	public struct PlayerData
+	{
+		public string PlayerName;
+		public int Level;
+		public int Score;
+		public float HealthPercentage;
+	}
+
+	/// <summary>
+	/// Example UI Presenter demonstrating data-driven UI
+	/// </summary>
+	public class DataUiExamplePresenter : UiPresenter<PlayerData>
+	{
+		[SerializeField] private Text _playerNameText;
+		[SerializeField] private Text _levelText;
+		[SerializeField] private Text _scoreText;
+		[SerializeField] private Slider _healthSlider;
+		[SerializeField] private Button _closeButton;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			Debug.Log("[DataUiExample] UI Initialized");
+			
+			if (_closeButton != null)
+			{
+				_closeButton.onClick.AddListener(() => Close(destroy: false));
+			}
+		}
+
+		protected override void OnSetData()
+		{
+			base.OnSetData();
+			Debug.Log($"[DataUiExample] Data Set: {Data.PlayerName}, Level {Data.Level}, Score {Data.Score}");
+			
+			UpdateUI();
+		}
+
+		protected override void OnOpened()
+		{
+			base.OnOpened();
+			Debug.Log("[DataUiExample] UI Opened");
+		}
+
+		private void UpdateUI()
+		{
+			if (_playerNameText != null)
+			{
+				_playerNameText.text = $"Player: {Data.PlayerName}";
+			}
+			
+			if (_levelText != null)
+			{
+				_levelText.text = $"Level: {Data.Level}";
+			}
+			
+			if (_scoreText != null)
+			{
+				_scoreText.text = $"Score: {Data.Score}";
+			}
+			
+			if (_healthSlider != null)
+			{
+				_healthSlider.value = Data.HealthPercentage;
+			}
+		}
+	}
+}
+
diff --git a/Samples~/DelayedPresenter/AnimatedUiExamplePresenter.cs b/Samples~/DelayedPresenter/AnimatedUiExamplePresenter.cs
new file mode 100644
index 0000000..9857d88
--- /dev/null
+++ b/Samples~/DelayedPresenter/AnimatedUiExamplePresenter.cs
@@ -0,0 +1,85 @@
+using UnityEngine;
+using UnityEngine.UI;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example UI Presenter with animation-based delays using the self-contained AnimationDelayFeature.
+	/// Demonstrates how animations automatically control timing and respond to animation completion.
+	/// </summary>
+	[RequireComponent(typeof(AnimationDelayFeature))]
+	public class AnimatedUiExamplePresenter : UiPresenter
+	{
+		[SerializeField] private AnimationDelayFeature _animationFeature;
+		[SerializeField] private Text _titleText;
+		[SerializeField] private Text _statusText;
+		[SerializeField] private Button _closeButton;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			Debug.Log("[AnimatedUiExample] UI Initialized");
+			
+			if (_closeButton != null)
+			{
+				_closeButton.onClick.AddListener(() => Close(destroy: false));
+			}
+			
+			// Subscribe to animation completion events
+			if (_animationFeature != null)
+			{
+				_animationFeature.OnOpenCompletedEvent += OnOpenAnimationCompleted;
+				_animationFeature.OnCloseCompletedEvent += OnCloseAnimationCompleted;
+			}
+		}
+
+		protected override void OnOpened()
+		{
+			base.OnOpened();
+			Debug.Log("[AnimatedUiExample] UI Opened, playing intro animation...");
+			
+			if (_titleText != null)
+			{
+				_titleText.text = "Animated UI Example";
+			}
+			
+			if (_statusText != null && _animationFeature != null)
+			{
+				var duration = _animationFeature.OpenDelayInSeconds;
+				_statusText.text = $"Playing intro animation ({duration:F2}s)...";
+			}
+		}
+
+		protected override void OnClosed()
+		{
+			base.OnClosed();
+			Debug.Log("[AnimatedUiExample] UI Closed, outro animation playing...");
+		}
+
+		private void OnOpenAnimationCompleted()
+		{
+			Debug.Log("[AnimatedUiExample] Intro animation completed!");
+			
+			if (_statusText != null)
+			{
+				_statusText.text = "Animation complete - Ready!";
+			}
+		}
+
+		private void OnCloseAnimationCompleted()
+		{
+			Debug.Log("[AnimatedUiExample] Outro animation completed!");
+		}
+
+		private void OnDestroy()
+		{
+			// Clean up event subscriptions
+			if (_animationFeature != null)
+			{
+				_animationFeature.OnOpenCompletedEvent -= OnOpenAnimationCompleted;
+				_animationFeature.OnCloseCompletedEvent -= OnCloseAnimationCompleted;
+			}
+		}
+	}
+}
diff --git a/Samples~/DelayedPresenter/DelayedPresenterExample.cs b/Samples~/DelayedPresenter/DelayedPresenterExample.cs
new file mode 100644
index 0000000..782bf12
--- /dev/null
+++ b/Samples~/DelayedPresenter/DelayedPresenterExample.cs
@@ -0,0 +1,55 @@
+using UnityEngine;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example demonstrating delayed UI presenters with animations and time delays
+	/// </summary>
+	public class DelayedPresenterExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+		
+		private IUiService _uiService;
+
+		private void Start()
+		{
+			// Initialize UI Service
+			_uiService = new UiService();
+			_uiService.Init(_uiConfigs);
+			
+			Debug.Log("=== Delayed Presenter Example Started ===");
+			Debug.Log("Press 1: Show Time-Delayed UI");
+			Debug.Log("Press 2: Show Animation-Delayed UI");
+			Debug.Log("Press 3: Close Active UI");
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				Debug.Log("Opening Time-Delayed UI (watch for delayed appearance)...");
+				_uiService.OpenUi<DelayedUiExamplePresenter>();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				Debug.Log("Opening Animation-Delayed UI (watch for animation)...");
+				_uiService.OpenUi<AnimatedUiExamplePresenter>();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha3))
+			{
+				Debug.Log("Closing UI...");
+				
+				if (_uiService.IsUiOpen<DelayedUiExamplePresenter>())
+				{
+					_uiService.CloseUi<DelayedUiExamplePresenter>(destroy: false);
+				}
+				else if (_uiService.IsUiOpen<AnimatedUiExamplePresenter>())
+				{
+					_uiService.CloseUi<AnimatedUiExamplePresenter>(destroy: false);
+				}
+			}
+		}
+	}
+}
+
diff --git a/Samples~/DelayedPresenter/DelayedUiExamplePresenter.cs b/Samples~/DelayedPresenter/DelayedUiExamplePresenter.cs
new file mode 100644
index 0000000..b5b0ef4
--- /dev/null
+++ b/Samples~/DelayedPresenter/DelayedUiExamplePresenter.cs
@@ -0,0 +1,84 @@
+using UnityEngine;
+using UnityEngine.UI;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example UI Presenter with time-based delays using the new self-contained TimeDelayFeature.
+	/// Demonstrates how to configure delays and respond to delay completion events.
+	/// </summary>
+	[RequireComponent(typeof(TimeDelayFeature))]
+	public class DelayedUiExamplePresenter : UiPresenter
+	{
+		[SerializeField] private TimeDelayFeature _delayFeature;
+		[SerializeField] private Text _titleText;
+		[SerializeField] private Text _statusText;
+		[SerializeField] private Button _closeButton;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			Debug.Log("[DelayedUiExample] UI Initialized");
+			
+			if (_closeButton != null)
+			{
+				_closeButton.onClick.AddListener(() => Close(destroy: false));
+			}
+			
+			// Subscribe to delay completion events
+			if (_delayFeature != null)
+			{
+				_delayFeature.OnOpenCompletedEvent += OnOpenDelayCompleted;
+				_delayFeature.OnCloseCompletedEvent += OnCloseDelayCompleted;
+			}
+		}
+
+		protected override void OnOpened()
+		{
+			base.OnOpened();
+			Debug.Log("[DelayedUiExample] UI Opened, starting delay...");
+			
+			if (_titleText != null)
+			{
+				_titleText.text = "Delayed UI Example";
+			}
+			
+			if (_statusText != null)
+			{
+				_statusText.text = $"Opening with {_delayFeature.OpenDelayInSeconds}s delay...";
+			}
+		}
+
+		protected override void OnClosed()
+		{
+			base.OnClosed();
+			Debug.Log($"[DelayedUiExample] UI Closed after {_delayFeature.CloseDelayInSeconds}s delay");
+		}
+
+		private void OnOpenDelayCompleted()
+		{
+			Debug.Log("[DelayedUiExample] Opening delay completed!");
+			
+			if (_statusText != null)
+			{
+				_statusText.text = $"Opened successfully after {_delayFeature.OpenDelayInSeconds}s!";
+			}
+		}
+
+		private void OnCloseDelayCompleted()
+		{
+			Debug.Log("[DelayedUiExample] Closing delay completed!");
+		}
+
+		private void OnDestroy()
+		{
+			// Clean up event subscriptions
+			if (_delayFeature != null)
+			{
+				_delayFeature.OnOpenCompletedEvent -= OnOpenDelayCompleted;
+				_delayFeature.OnCloseCompletedEvent -= OnCloseDelayCompleted;
+			}
+		}
+	}
+}
diff --git a/Samples~/DelayedUiToolkit/AnimationDelayedUiToolkitPresenter.cs b/Samples~/DelayedUiToolkit/AnimationDelayedUiToolkitPresenter.cs
new file mode 100644
index 0000000..33a42a4
--- /dev/null
+++ b/Samples~/DelayedUiToolkit/AnimationDelayedUiToolkitPresenter.cs
@@ -0,0 +1,138 @@
+using GameLovers.UiService;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace GameLovers.UiServiceExamples
+{
+	/// <summary>
+	/// Data structure for the animated UI Toolkit example
+	/// </summary>
+	public struct UiToolkitExampleData
+	{
+		public string Title;
+		public string Message;
+		public int Score;
+	}
+
+	/// <summary>
+	/// Example implementation using animation-based delays with UI Toolkit and data.
+	/// Demonstrates how to combine AnimationDelayFeature, UiToolkitPresenterFeature, and presenter data.
+	/// 
+	/// Setup:
+	/// 1. Attach this component to a GameObject
+	/// 2. Add AnimationDelayFeature component
+	/// 3. Add Animation component and assign intro/outro animation clips
+	/// 4. Add UIDocument component
+	/// 5. Create a UXML file with elements: Title, Message, Score (Labels), CloseButton (Button)
+	/// 6. Assign the UXML to the UIDocument
+	/// </summary>
+	[RequireComponent(typeof(AnimationDelayFeature))]
+	[RequireComponent(typeof(UiToolkitPresenterFeature))]
+	public class AnimationDelayedUiToolkitPresenter : UiPresenter<UiToolkitExampleData>
+	{
+		[SerializeField] private AnimationDelayFeature _animationFeature;
+		[SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+
+		private Label _titleLabel;
+		private Label _messageLabel;
+		private Label _scoreLabel;
+		private Label _statusLabel;
+		private Button _closeButton;
+
+		/// <inheritdoc />
+		protected override void OnInitialized()
+		{
+			Debug.Log("AnimationDelayedUiToolkitPresenter: Initialized");
+
+			// Subscribe to animation completion
+			if (_animationFeature != null)
+			{
+				_animationFeature.OnOpenCompletedEvent += OnOpenAnimationCompleted;
+			}
+
+			// Query UI Toolkit elements
+			var root = _toolkitFeature.Root;
+			_titleLabel = root.Q<Label>("Title");
+			_messageLabel = root.Q<Label>("Message");
+			_scoreLabel = root.Q<Label>("Score");
+			_statusLabel = root.Q<Label>("Status");
+			_closeButton = root.Q<Button>("CloseButton");
+
+			// Setup button event
+			if (_closeButton != null)
+			{
+				_closeButton.clicked += OnCloseButtonClicked;
+			}
+		}
+
+		/// <inheritdoc />
+		protected override void OnSetData()
+		{
+			Debug.Log($"AnimationDelayedUiToolkitPresenter: Data set - {Data.Title}");
+
+			// Update UI elements with the provided data
+			if (_titleLabel != null)
+			{
+				_titleLabel.text = Data.Title;
+			}
+
+			if (_messageLabel != null)
+			{
+				_messageLabel.text = Data.Message;
+			}
+
+			if (_scoreLabel != null)
+			{
+				_scoreLabel.text = $"Score: {Data.Score}";
+			}
+		}
+
+		/// <inheritdoc />
+		protected override void OnOpened()
+		{
+			Debug.Log("AnimationDelayedUiToolkitPresenter: Opened, playing intro animation...");
+			
+			if (_statusLabel != null && _animationFeature != null)
+			{
+				var duration = _animationFeature.OpenDelayInSeconds;
+				_statusLabel.text = $"Playing animation ({duration:F2}s)...";
+			}
+		}
+
+		private void OnOpenAnimationCompleted()
+		{
+			Debug.Log("AnimationDelayedUiToolkitPresenter: Opening animation completed!");
+			
+			// Update UI after animation
+			if (_statusLabel != null)
+			{
+				_statusLabel.text = "Animation Complete!";
+			}
+
+			if (_messageLabel != null)
+			{
+				_messageLabel.text = Data.Message + " (Ready)";
+			}
+		}
+
+		private void OnCloseButtonClicked()
+		{
+			Debug.Log("Close button clicked, closing UI with animation...");
+			Close(false);
+		}
+
+		private void OnDestroy()
+		{
+			// Clean up event subscriptions
+			if (_animationFeature != null)
+			{
+				_animationFeature.OnOpenCompletedEvent -= OnOpenAnimationCompleted;
+			}
+
+			if (_closeButton != null)
+			{
+				_closeButton.clicked -= OnCloseButtonClicked;
+			}
+		}
+	}
+}
diff --git a/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.cs b/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.cs
new file mode 100644
index 0000000..a02b388
--- /dev/null
+++ b/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.cs
@@ -0,0 +1,86 @@
+using GameLovers.UiService;
+using UnityEngine;
+
+namespace GameLovers.UiServiceExamples
+{
+	/// <summary>
+	/// Example demonstrating the <see cref="DelayUiToolkitPresenter"/> functionality.
+	/// This example shows how to combine UI Toolkit rendering with delay-based transitions.
+	/// 
+	/// Press number keys to test different scenarios:
+	/// - 1: Open time-delayed UI Toolkit presenter
+	/// - 2: Open animation-delayed UI Toolkit presenter with data
+	/// - 3: Close all UIs
+	/// </summary>
+	public class DelayedUiToolkitExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+
+		private IUiService _uiService;
+
+		private void Start()
+		{
+			// Initialize the UI service
+			_uiService = new UiService(_uiConfigs, new UiAssetLoader());
+
+			Debug.Log("=== Delayed UI Toolkit Example ===");
+			Debug.Log("Press 1: Open Time-Delayed UI Toolkit");
+			Debug.Log("Press 2: Open Animation-Delayed UI Toolkit with Data");
+			Debug.Log("Press 3: Close All UIs");
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				OpenTimeDelayedUiToolkit();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				OpenAnimationDelayedUiToolkit();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha3))
+			{
+				CloseAllUis();
+			}
+		}
+
+		/// <summary>
+		/// Opens a UI Toolkit presenter with time-based delays
+		/// </summary>
+		private async void OpenTimeDelayedUiToolkit()
+		{
+			Debug.Log("Opening Time-Delayed UI Toolkit Presenter...");
+			await _uiService.OpenUi<TimeDelayedUiToolkitPresenter>();
+			Debug.Log("Time-Delayed UI Toolkit Presenter opened!");
+		}
+
+		/// <summary>
+		/// Opens a UI Toolkit presenter with animation-based delays and data
+		/// </summary>
+		private async void OpenAnimationDelayedUiToolkit()
+		{
+			var data = new UiToolkitExampleData
+			{
+				Title = "Animated UI Toolkit",
+				Message = "This UI uses animation delays!",
+				Score = Random.Range(100, 999)
+			};
+
+			Debug.Log($"Opening Animation-Delayed UI Toolkit with data: {data.Title}");
+			await _uiService.OpenUi<AnimationDelayedUiToolkitPresenter, UiToolkitExampleData>(data);
+			Debug.Log("Animation-Delayed UI Toolkit Presenter opened!");
+		}
+
+		/// <summary>
+		/// Closes all open UIs
+		/// </summary>
+		private void CloseAllUis()
+		{
+			Debug.Log("Closing all UIs...");
+			_uiService.CloseUi<TimeDelayedUiToolkitPresenter>();
+			_uiService.CloseUi<AnimationDelayedUiToolkitPresenter>();
+		}
+	}
+}
+
diff --git a/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.uxml b/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.uxml
new file mode 100644
index 0000000..b0d1f6a
--- /dev/null
+++ b/Samples~/DelayedUiToolkit/DelayedUiToolkitExample.uxml
@@ -0,0 +1,11 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
+    <ui:VisualElement name="Container" style="flex-grow: 1; background-color: rgba(0, 0, 0, 0.8); align-items: center; justify-content: center;">
+        <ui:VisualElement name="Panel" style="background-color: rgb(45, 45, 48); padding-left: 20px; padding-right: 20px; padding-top: 20px; padding-bottom: 20px; border-top-left-radius: 10px; border-bottom-left-radius: 10px; border-top-right-radius: 10px; border-bottom-right-radius: 10px; min-width: 400px; min-height: 300px; align-items: center; justify-content: center;">
+            <ui:Label text="Title" display-tooltip-when-elided="true" name="Title" style="font-size: 32px; -unity-font-style: bold; color: rgb(255, 255, 255); margin-bottom: 20px;" />
+            <ui:Label text="Message" display-tooltip-when-elided="true" name="Message" style="font-size: 18px; color: rgb(200, 200, 200); margin-bottom: 10px; white-space: normal; max-width: 350px;" />
+            <ui:Label text="Score: 0" display-tooltip-when-elided="true" name="Score" style="font-size: 24px; -unity-font-style: bold; color: rgb(100, 200, 255); margin-top: 20px; margin-bottom: 30px;" />
+            <ui:Button text="Close" display-tooltip-when-elided="true" name="CloseButton" style="padding-left: 30px; padding-right: 30px; padding-top: 10px; padding-bottom: 10px; font-size: 18px; background-color: rgb(200, 50, 50); color: rgb(255, 255, 255); border-top-left-radius: 5px; border-bottom-left-radius: 5px; border-top-right-radius: 5px; border-bottom-right-radius: 5px;" />
+        </ui:VisualElement>
+    </ui:VisualElement>
+</ui:UXML>
+
diff --git a/Samples~/DelayedUiToolkit/TimeDelayedUiToolkitPresenter.cs b/Samples~/DelayedUiToolkit/TimeDelayedUiToolkitPresenter.cs
new file mode 100644
index 0000000..3b389d2
--- /dev/null
+++ b/Samples~/DelayedUiToolkit/TimeDelayedUiToolkitPresenter.cs
@@ -0,0 +1,105 @@
+using GameLovers.UiService;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace GameLovers.UiServiceExamples
+{
+	/// <summary>
+	/// Example implementation using time-based delays with UI Toolkit.
+	/// Demonstrates how to combine TimeDelayFeature and UiToolkitPresenterFeature.
+	/// 
+	/// Setup:
+	/// 1. Attach this component to a GameObject
+	/// 2. Add TimeDelayFeature component (configure delay times in inspector)
+	/// 3. Add UIDocument component
+	/// 4. Create a UXML file with elements: Title (Label), Status (Label), CloseButton (Button)
+	/// 5. Assign the UXML to the UIDocument
+	/// </summary>
+	[RequireComponent(typeof(TimeDelayFeature))]
+	[RequireComponent(typeof(UiToolkitPresenterFeature))]
+	public class TimeDelayedUiToolkitPresenter : UiPresenter
+	{
+		[SerializeField] private TimeDelayFeature _delayFeature;
+		[SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+
+		private Label _titleLabel;
+		private Label _statusLabel;
+		private Button _closeButton;
+
+		/// <inheritdoc />
+		protected override void OnInitialized()
+		{
+			Debug.Log("TimeDelayedUiToolkitPresenter: Initialized");
+
+			// Subscribe to delay completion
+			if (_delayFeature != null)
+			{
+				_delayFeature.OnOpenCompletedEvent += OnOpenDelayCompleted;
+			}
+
+			// Query UI Toolkit elements
+			var root = _toolkitFeature.Root;
+			_titleLabel = root.Q<Label>("Title");
+			_statusLabel = root.Q<Label>("Status");
+			_closeButton = root.Q<Button>("CloseButton");
+
+			// Setup UI elements
+			if (_titleLabel != null)
+			{
+				_titleLabel.text = "Time-Delayed UI Toolkit";
+			}
+
+			if (_closeButton != null)
+			{
+				_closeButton.clicked += OnCloseButtonClicked;
+			}
+		}
+
+		/// <inheritdoc />
+		protected override void OnOpened()
+		{
+			Debug.Log("TimeDelayedUiToolkitPresenter: Opened, starting delay...");
+			
+			if (_statusLabel != null && _delayFeature != null)
+			{
+				_statusLabel.text = $"Opening with {_delayFeature.OpenDelayInSeconds}s delay...";
+			}
+		}
+
+		private void OnOpenDelayCompleted()
+		{
+			Debug.Log("TimeDelayedUiToolkitPresenter: Opening delay completed!");
+			
+			// Update UI after delay
+			if (_statusLabel != null)
+			{
+				_statusLabel.text = "Ready!";
+			}
+
+			if (_titleLabel != null)
+			{
+				_titleLabel.text = "Time-Delayed UI Toolkit - Ready!";
+			}
+		}
+
+		private void OnCloseButtonClicked()
+		{
+			Debug.Log("Close button clicked, closing UI...");
+			Close(false);
+		}
+
+		private void OnDestroy()
+		{
+			// Clean up event subscriptions
+			if (_delayFeature != null)
+			{
+				_delayFeature.OnOpenCompletedEvent -= OnOpenDelayCompleted;
+			}
+
+			if (_closeButton != null)
+			{
+				_closeButton.clicked -= OnCloseButtonClicked;
+			}
+		}
+	}
+}
diff --git a/Samples~/README.md b/Samples~/README.md
new file mode 100644
index 0000000..3cdac2b
--- /dev/null
+++ b/Samples~/README.md
@@ -0,0 +1,426 @@
+# UI Service Samples
+
+This folder contains example implementations demonstrating the **pure feature composition** pattern of the UI Service.
+
+---
+
+## Architecture Overview
+
+All samples use the new self-contained feature pattern:
+- **Base:** `UiPresenter` or `UiPresenter<T>`
+- **Features:** Self-contained components (TimeDelayFeature, AnimationDelayFeature, UiToolkitPresenterFeature)
+- **Composition:** Mix features as needed using `[RequireComponent]`
+
+---
+
+## Samples Included
+
+### 1. BasicUiFlow
+
+**Files:**
+- `BasicUiExamplePresenter.cs` - Simple presenter without features
+- `BasicUiFlowExample.cs` - Scene setup and UI service usage
+
+**Demonstrates:**
+- Basic UI presenter lifecycle
+- Opening and closing UI
+- Simple button interactions
+
+**Pattern:**
+```csharp
+public class BasicUiExamplePresenter : UiPresenter
+{
+    protected override void OnOpened() { }
+    protected override void OnClosed() { }
+}
+```
+
+---
+
+### 2. DataPresenter
+
+**Files:**
+- `DataUiExamplePresenter.cs` - Presenter with data
+- `DataPresenterExample.cs` - Data-driven UI example
+
+**Demonstrates:**
+- Using `UiPresenter<T>` for data-driven UI
+- Setting and accessing presenter data
+- `OnSetData()` lifecycle hook
+
+**Pattern:**
+```csharp
+public struct MyData
+{
+    public string Title;
+}
+
+public class DataUiExamplePresenter : UiPresenter<MyData>
+{
+    protected override void OnSetData()
+    {
+        // Use Data.Title
+    }
+}
+```
+
+---
+
+### 3. DelayedPresenter
+
+**Files:**
+- `DelayedUiExamplePresenter.cs` - Time-based delays
+- `AnimatedUiExamplePresenter.cs` - Animation-based delays
+- `DelayedPresenterExample.cs` - Scene setup
+
+**Demonstrates:**
+- Using `TimeDelayFeature` for time-based delays
+- Using `AnimationDelayFeature` for animation-synchronized delays
+- Subscribing to delay completion events
+- Configuring delays in inspector
+
+**Pattern (Time Delay):**
+```csharp
+[RequireComponent(typeof(TimeDelayFeature))]
+public class DelayedUiExamplePresenter : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    
+    protected override void OnInitialized()
+    {
+        _delayFeature.OnOpenCompletedEvent += OnDelayComplete;
+    }
+    
+    private void OnDelayComplete()
+    {
+        // Called after delay finishes
+    }
+    
+    private void OnDestroy()
+    {
+        _delayFeature.OnOpenCompletedEvent -= OnDelayComplete;
+    }
+}
+```
+
+**Pattern (Animation Delay):**
+```csharp
+[RequireComponent(typeof(AnimationDelayFeature))]
+public class AnimatedUiExamplePresenter : UiPresenter
+{
+    [SerializeField] private AnimationDelayFeature _animationFeature;
+    
+    protected override void OnInitialized()
+    {
+        _animationFeature.OnOpenCompletedEvent += OnAnimationComplete;
+    }
+    
+    private void OnAnimationComplete()
+    {
+        // Called after animation finishes
+    }
+}
+```
+
+**Setup:**
+1. Attach presenter to GameObject
+2. Add `TimeDelayFeature` or `AnimationDelayFeature` component
+3. Configure delay times (time) or animation clips (animation) in inspector
+4. Feature handles all timing automatically
+
+---
+
+### 4. UiToolkit
+
+**Files:**
+- `UiToolkitExamplePresenter.cs` - UI Toolkit presenter
+- `UiToolkitExample.cs` - Scene setup
+- `UiToolkitExample.uxml` - UI Toolkit layout
+
+**Demonstrates:**
+- Using `UiToolkitPresenterFeature` for UI Toolkit integration
+- Querying VisualElements from the root
+- Binding UI Toolkit events
+- Clean event subscription management
+
+**Pattern:**
+```csharp
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class UiToolkitExamplePresenter : UiPresenter
+{
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    protected override void OnInitialized()
+    {
+        var root = _toolkitFeature.Root;
+        var button = root.Q<Button>("MyButton");
+        button.clicked += OnButtonClicked;
+    }
+    
+    private void OnButtonClicked()
+    {
+        // Handle button click
+    }
+}
+```
+
+**Setup:**
+1. Attach presenter to GameObject
+2. Add `UiToolkitPresenterFeature` component (auto-detects UIDocument)
+3. Create UXML file with your UI elements
+4. Assign UXML to UIDocument in inspector
+
+---
+
+### 5. DelayedUiToolkit
+
+**Files:**
+- `TimeDelayedUiToolkitPresenter.cs` - Time delay + UI Toolkit
+- `AnimationDelayedUiToolkitPresenter.cs` - Animation delay + UI Toolkit + Data
+- `DelayedUiToolkitExample.cs` - Scene setup
+- `DelayedUiToolkitExample.uxml` - UI Toolkit layout
+
+**Demonstrates:**
+- **Composing multiple features together**
+- Combining TimeDelayFeature/AnimationDelayFeature + UiToolkitPresenterFeature
+- Using data with multiple features
+- Coordinating feature interactions
+
+**Pattern (Time Delay + UI Toolkit):**
+```csharp
+[RequireComponent(typeof(TimeDelayFeature))]
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class TimeDelayedUiToolkitPresenter : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    protected override void OnInitialized()
+    {
+        // Disable UI until delay completes
+        _toolkitFeature.Root.SetEnabled(false);
+        _delayFeature.OnOpenCompletedEvent += EnableUI;
+    }
+    
+    private void EnableUI()
+    {
+        _toolkitFeature.Root.SetEnabled(true);
+    }
+}
+```
+
+**Pattern (Animation + UI Toolkit + Data):**
+```csharp
+[RequireComponent(typeof(AnimationDelayFeature))]
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class AnimationDelayedUiToolkitPresenter : UiPresenter<MyData>
+{
+    [SerializeField] private AnimationDelayFeature _animationFeature;
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    protected override void OnSetData()
+    {
+        // Update UI with data
+        _toolkitFeature.Root.Q<Label>("Title").text = Data.Title;
+    }
+    
+    protected override void OnInitialized()
+    {
+        _animationFeature.OnOpenCompletedEvent += OnAnimationComplete;
+    }
+    
+    private void OnAnimationComplete()
+    {
+        // Enable interactions after animation
+        _toolkitFeature.Root.SetEnabled(true);
+    }
+}
+```
+
+**Setup:**
+1. Attach presenter to GameObject
+2. Add both feature components
+3. Configure each feature in inspector
+4. Features work together automatically
+
+---
+
+### 6. Analytics
+
+**Files:**
+- `AnalyticsCallbackExample.cs` - Analytics integration example
+
+**Demonstrates:**
+- Integrating analytics with UI events
+- Tracking UI opens/closes
+- Custom analytics callbacks
+
+---
+
+## Common Patterns
+
+### Feature Configuration
+
+#### TimeDelayFeature
+Configure in inspector:
+- **Open Delay In Seconds:** Time to wait after opening (default: 0.5s)
+- **Close Delay In Seconds:** Time to wait before closing (default: 0.3s)
+
+#### AnimationDelayFeature
+Configure in inspector:
+- **Animation Component:** Auto-detected or manually assigned
+- **Intro Animation Clip:** Animation to play when opening
+- **Outro Animation Clip:** Animation to play when closing
+
+Delays automatically match animation clip lengths!
+
+#### UiToolkitPresenterFeature
+Configure in inspector:
+- **Document:** Auto-detected UIDocument component
+- Access via: `_toolkitFeature.Document` or `_toolkitFeature.Root`
+
+---
+
+### Event Subscription Pattern
+
+Always subscribe in `OnInitialized()` and unsubscribe in `OnDestroy()`:
+
+```csharp
+protected override void OnInitialized()
+{
+    _delayFeature.OnOpenCompletedEvent += MyHandler;
+}
+
+private void OnDestroy()
+{
+    if (_delayFeature != null)
+    {
+        _delayFeature.OnOpenCompletedEvent -= MyHandler;
+    }
+}
+```
+
+---
+
+### Multiple Features Pattern
+
+```csharp
+[RequireComponent(typeof(TimeDelayFeature))]
+[RequireComponent(typeof(UiToolkitPresenterFeature))]
+public class MyPresenter : UiPresenter
+{
+    [SerializeField] private TimeDelayFeature _delayFeature;
+    [SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+    
+    // Use both features together!
+}
+```
+
+---
+
+## Creating Custom Features
+
+Follow this pattern to create your own features:
+
+```csharp
+using UnityEngine;
+using GameLovers.UiService;
+
+/// <summary>
+/// Custom feature that adds fade effect
+/// </summary>
+[RequireComponent(typeof(CanvasGroup))]
+public class FadeFeature : PresenterFeatureBase
+{
+    [SerializeField] private CanvasGroup _canvasGroup;
+    [SerializeField] private float _fadeDuration = 0.3f;
+    
+    private void OnValidate()
+    {
+        _canvasGroup = _canvasGroup ?? GetComponent<CanvasGroup>();
+    }
+    
+    public override void OnPresenterOpening()
+    {
+        _canvasGroup.alpha = 0f;
+    }
+    
+    public override void OnPresenterOpened()
+    {
+        StartCoroutine(FadeIn());
+    }
+    
+    private IEnumerator FadeIn()
+    {
+        float elapsed = 0f;
+        while (elapsed < _fadeDuration)
+        {
+            _canvasGroup.alpha = elapsed / _fadeDuration;
+            elapsed += Time.deltaTime;
+            yield return null;
+        }
+        _canvasGroup.alpha = 1f;
+    }
+}
+```
+
+Use it:
+```csharp
+[RequireComponent(typeof(FadeFeature))]
+public class MyFadingPresenter : UiPresenter
+{
+    // Fade happens automatically!
+}
+```
+
+---
+
+## Best Practices
+
+### 1. One Component Per Feature
+Each feature is self-contained - no need for separate delayer components.
+
+### 2. Clean Up Events
+Always unsubscribe from events in `OnDestroy()`.
+
+### 3. Use OnValidate
+Let Unity auto-assign component references in `OnValidate()`.
+
+### 4. Configure in Inspector
+Use `[SerializeField]` and let designers configure values in Unity's inspector.
+
+### 5. Compose Freely
+Mix and match features without worrying about inheritance conflicts.
+
+---
+
+## Architecture Benefits
+
+✅ **Self-Contained** - Each feature owns its complete logic  
+✅ **Composable** - Mix any features freely  
+✅ **Configurable** - All settings in Unity inspector  
+✅ **Clear** - One component = one capability  
+✅ **Scalable** - Add new features without modifying existing code  
+
+---
+
+## Getting Started
+
+1. **Choose a sample** that matches your use case
+2. **Copy the pattern** to your own presenter
+3. **Add required features** via `[RequireComponent]`
+4. **Configure in inspector** - delays, animations, etc.
+5. **Subscribe to events** for feature completion notifications
+
+---
+
+## Documentation
+
+For complete architecture documentation, see:
+- **[README.md](../README.md)** - Quick start guide
+- **[FINAL_SIMPLIFICATION.md](../FINAL_SIMPLIFICATION.md)** - Architecture details
+- **[FINAL_ARCHITECTURE_SUMMARY.md](../FINAL_ARCHITECTURE_SUMMARY.md)** - Complete overview
+
+---
+
+**All samples use the pure feature composition pattern introduced in architecture v2.0**
diff --git a/Samples~/UiToolkit/UiToolkitExample.cs b/Samples~/UiToolkit/UiToolkitExample.cs
new file mode 100644
index 0000000..eaef4ca
--- /dev/null
+++ b/Samples~/UiToolkit/UiToolkitExample.cs
@@ -0,0 +1,43 @@
+using UnityEngine;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example demonstrating UI Toolkit integration with UiService
+	/// </summary>
+	public class UiToolkitExample : MonoBehaviour
+	{
+		[SerializeField] private UiConfigs _uiConfigs;
+		
+		private IUiService _uiService;
+
+		private void Start()
+		{
+			// Initialize UI Service
+			_uiService = new UiService();
+			_uiService.Init(_uiConfigs);
+			
+			Debug.Log("=== UI Toolkit Example Started ===");
+			Debug.Log("Press 1: Open UI Toolkit UI");
+			Debug.Log("Press 2: Close UI Toolkit UI");
+			Debug.Log("");
+			Debug.Log("Note: Make sure to create a UXML document and assign it to the UIDocument component");
+		}
+
+		private void Update()
+		{
+			if (Input.GetKeyDown(KeyCode.Alpha1))
+			{
+				Debug.Log("Opening UI Toolkit UI...");
+				_uiService.OpenUi<UiToolkitExamplePresenter>();
+			}
+			else if (Input.GetKeyDown(KeyCode.Alpha2))
+			{
+				Debug.Log("Closing UI Toolkit UI...");
+				_uiService.CloseUi<UiToolkitExamplePresenter>(destroy: false);
+			}
+		}
+	}
+}
+
diff --git a/Samples~/UiToolkit/UiToolkitExample.uxml b/Samples~/UiToolkit/UiToolkitExample.uxml
new file mode 100644
index 0000000..1067504
--- /dev/null
+++ b/Samples~/UiToolkit/UiToolkitExample.uxml
@@ -0,0 +1,15 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
+    <ui:VisualElement style="flex-grow: 1; background-color: rgba(0, 0, 0, 0.8); align-items: center; justify-content: center;">
+        <ui:VisualElement style="background-color: rgb(45, 45, 48); padding: 20px; border-radius: 10px; min-width: 400px; min-height: 300px;">
+            <ui:Label name="TitleLabel" text="UI Toolkit Example" style="font-size: 24px; -unity-font-style: bold; margin-bottom: 10px; -unity-text-align: upper-center;" />
+            <ui:Label name="DescriptionLabel" text="This UI uses Unity&apos;s UI Toolkit system" style="font-size: 14px; margin-bottom: 20px; -unity-text-align: upper-center;" />
+            
+            <ui:VisualElement style="flex-grow: 1; align-items: center; justify-content: center;">
+                <ui:Label name="CounterLabel" text="Count: 0" style="font-size: 36px; -unity-font-style: bold; margin-bottom: 20px;" />
+                <ui:Button name="IncrementButton" text="Increment" style="width: 200px; height: 50px; font-size: 18px; margin-bottom: 10px;" />
+                <ui:Button name="CloseButton" text="Close" style="width: 200px; height: 50px; font-size: 18px;" />
+            </ui:VisualElement>
+        </ui:VisualElement>
+    </ui:VisualElement>
+</ui:UXML>
+
diff --git a/Samples~/UiToolkit/UiToolkitExamplePresenter.cs b/Samples~/UiToolkit/UiToolkitExamplePresenter.cs
new file mode 100644
index 0000000..d66aecf
--- /dev/null
+++ b/Samples~/UiToolkit/UiToolkitExamplePresenter.cs
@@ -0,0 +1,97 @@
+using UnityEngine;
+using UnityEngine.UIElements;
+using GameLovers.UiService;
+
+namespace GameLovers.UiService.Examples
+{
+	/// <summary>
+	/// Example UI Presenter using Unity's UI Toolkit with the self-contained UiToolkitPresenterFeature.
+	/// Demonstrates how to work with UI Toolkit elements using the feature composition pattern.
+	/// </summary>
+	[RequireComponent(typeof(UiToolkitPresenterFeature))]
+	public class UiToolkitExamplePresenter : UiPresenter
+	{
+		[SerializeField] private UiToolkitPresenterFeature _toolkitFeature;
+
+		private Label _titleLabel;
+		private Label _descriptionLabel;
+		private Button _incrementButton;
+		private Button _closeButton;
+		private Label _counterLabel;
+		
+		private int _counter = 0;
+
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			Debug.Log("[UiToolkitExample] UI Initialized");
+			
+			// Get UI elements from the VisualElement root
+			var root = _toolkitFeature.Root;
+			_titleLabel = root.Q<Label>("TitleLabel");
+			_descriptionLabel = root.Q<Label>("DescriptionLabel");
+			_incrementButton = root.Q<Button>("IncrementButton");
+			_closeButton = root.Q<Button>("CloseButton");
+			_counterLabel = root.Q<Label>("CounterLabel");
+			
+			// Set up event handlers
+			if (_incrementButton != null)
+			{
+				_incrementButton.clicked += OnIncrementClicked;
+			}
+			
+			if (_closeButton != null)
+			{
+				_closeButton.clicked += () => Close(destroy: false);
+			}
+		}
+
+		protected override void OnOpened()
+		{
+			base.OnOpened();
+			Debug.Log("[UiToolkitExample] UI Opened");
+			
+			if (_titleLabel != null)
+			{
+				_titleLabel.text = "UI Toolkit Example";
+			}
+			
+			if (_descriptionLabel != null)
+			{
+				_descriptionLabel.text = "This UI uses Unity's UI Toolkit with feature composition";
+			}
+			
+			UpdateCounter();
+		}
+
+		protected override void OnClosed()
+		{
+			base.OnClosed();
+			Debug.Log("[UiToolkitExample] UI Closed");
+		}
+
+		private void OnIncrementClicked()
+		{
+			_counter++;
+			UpdateCounter();
+			Debug.Log($"[UiToolkitExample] Counter incremented to {_counter}");
+		}
+
+		private void UpdateCounter()
+		{
+			if (_counterLabel != null)
+			{
+				_counterLabel.text = $"Count: {_counter}";
+			}
+		}
+
+		private void OnDestroy()
+		{
+			// Clean up event handlers
+			if (_incrementButton != null)
+			{
+				_incrementButton.clicked -= OnIncrementClicked;
+			}
+		}
+	}
+}
diff --git a/package.json b/package.json
index 8350234..a6f4d87 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "com.gamelovers.uiservice",
   "displayName": "UiService",
   "author": "Miguel Tomas",
-  "version": "0.13.1",
+  "version": "1.0.0",
   "unity": "6000.0",
   "license": "MIT",
   "description": "This package provides a service to help manage an Unity's, game UI.\nIt allows to open, close, load, unload and request any Ui Configured in the game.\nThe package provides a Ui Set that allows to group a set of Ui Presenters to help load, open and close multiple Uis at the same time.\n\nTo help configure the game's UI you need to create a UiConfigs Scriptable object by:\n- Right Click on the Project View > Create > ScriptableObjects > Configs > UiConfigs",