diff --git a/com.dotsui.core/CHANGELOG.md b/com.dotsui.core/CHANGELOG.md
index 6700d61..2022dfd 100644
--- a/com.dotsui.core/CHANGELOG.md
+++ b/com.dotsui.core/CHANGELOG.md
@@ -2,6 +2,19 @@
 
 **This file contains changelog for all DotsUI packages**
 
+## [0.5.0] 2019-12-15
+
+### Added
+
+* Toggle control
+
+
+### Changes
+
+* Refactored input system (significant performance improvement)
+* Implemented dedicated parent system. It works with the same components, but write group prevents some Unity.Transforms systems from querying entities with RectTransfrom. This way we can remove some unnecessary components (like LocalToWorld and LocalToParent) and see a great performance boost.
+
+
 ## [0.4.0] 2019-09-11
 
 ### Added
diff --git a/com.dotsui.core/DotsUI.Controls/ButtonSystem.cs b/com.dotsui.core/DotsUI.Controls/ButtonSystem.cs
index 8ddaa0a..1226e6f 100644
--- a/com.dotsui.core/DotsUI.Controls/ButtonSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/ButtonSystem.cs
@@ -1,4 +1,5 @@
-using DotsUI.Core;
+using System.Diagnostics;
+using DotsUI.Core;
 using DotsUI.Core.Utils;
 using DotsUI.Input;
 using Unity.Entities;
@@ -9,72 +10,39 @@
 namespace DotsUI.Controls
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
     public class ButtonSystem : JobComponentSystem
     {
-        private EntityQuery m_EventGroup;
         private InputHandleBarrier m_Barrier;
 
+        private PointerEventQuery m_PointerQuery;
+
         protected override void OnCreate()
         {
             m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
-            m_EventGroup = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new[]
-                {
-                    ComponentType.ReadWrite<PointerInputBuffer>(),
-                    ComponentType.ReadWrite<PointerEvent>()
-                }
-            });
+            GetEntityQuery(ComponentType.ReadOnly<Button>());
+            m_PointerQuery = PointerEventQuery.Create<Button>(EntityManager);
         }
 
         protected override void OnDestroy()
         {
         }
-        [BurstCompile]
-        private struct ProcessClicks : IJobChunk
-        {
-            [ReadOnly] public ArchetypeChunkComponentType<PointerEvent> EventType;
-            [ReadOnly] public ArchetypeChunkBufferType<PointerInputBuffer> BufferType;
 
-            [WriteOnly] public AddFlagComponentCommandBuffer.ParallelWriter ClickedButtons;
-            [ReadOnly] public ComponentDataFromEntity<Button> ButtonTargetType;
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
+        {
+            var reader = m_PointerQuery.CreatePointerEventReader(Allocator.TempJob);
 
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            for (int i = 0; i < reader.EntityCount; i++)
             {
-                var eventArray = chunk.GetNativeArray(EventType);
-                var bufferAccessor = chunk.GetBufferAccessor(BufferType);
-                for (int i = 0; i < chunk.Count; i++)
+                foreach (var ev in reader.GetEventsForTargetEntity(reader[i]))
                 {
-                    if (ButtonTargetType.Exists(eventArray[i].Target))
-                    {
-                        var buff = bufferAccessor[i];
-                        for (int j = 0; j < buff.Length; j++)
-                        {
-                            if (buff[j].EventType == PointerEventType.Click)
-                            {
-                                ClickedButtons.TryAdd(eventArray[i].Target);
-                            }
-                        }
-                    }
-
+                    if (ev.EventType == PointerEventType.Click)
+                        EntityManager.AddComponent<ButtonClickedEvent>(reader[i]);
                 }
             }
-        }
 
-        protected override JobHandle OnUpdate(JobHandle inputDeps)
-        {
-            var commandBuff = m_Barrier.CreateAddFlagComponentCommandBuffer<ButtonClickedEvent>();
-            ProcessClicks clicksJob = new ProcessClicks
-            {
-                BufferType = GetArchetypeChunkBufferType<PointerInputBuffer>(),
-                EventType = GetArchetypeChunkComponentType<PointerEvent>(),
-                ButtonTargetType = GetComponentDataFromEntity<Button>(),
-                ClickedButtons = commandBuff.AsParallelWriter()
-            };
-            inputDeps = clicksJob.Schedule(m_EventGroup, inputDeps);
-            m_Barrier.AddJobHandleForProducer(inputDeps);
+            inputDeps = reader.Dispose(inputDeps);
             return inputDeps;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Controls/ControlsCleanupSystem.cs b/com.dotsui.core/DotsUI.Controls/ControlsCleanupSystem.cs
index c20d9cd..db6f013 100644
--- a/com.dotsui.core/DotsUI.Controls/ControlsCleanupSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/ControlsCleanupSystem.cs
@@ -10,6 +10,7 @@ class ControlsCleanupSystem : ComponentSystem
         private EntityQuery m_InputFieldEndEditQuery;
         private EntityQuery m_InputFieldReturnQuery;
         private EntityQuery m_SliderValueChangedQuery;
+        private EntityQuery m_ToggleValueChangedQuery;
 
         protected override void OnCreate()
         {
@@ -17,6 +18,7 @@ protected override void OnCreate()
             m_SliderValueChangedQuery = GetEntityQuery(typeof(SliderValueChangedEvent));
             m_InputFieldEndEditQuery = GetEntityQuery(typeof(InputFieldEndEditEvent));
             m_InputFieldReturnQuery = GetEntityQuery(typeof(InputFieldReturnEvent));
+            m_ToggleValueChangedQuery = GetEntityQuery(typeof(ToggleValueChangedEvent));
         }
 
         protected override void OnUpdate()
@@ -25,6 +27,7 @@ protected override void OnUpdate()
             EntityManager.RemoveComponent(m_SliderValueChangedQuery, typeof(SliderValueChangedEvent));
             EntityManager.RemoveComponent(m_InputFieldEndEditQuery, typeof(InputFieldEndEditEvent));
             EntityManager.RemoveComponent(m_InputFieldReturnQuery, typeof(InputFieldReturnEvent));
+            EntityManager.RemoveComponent(m_ToggleValueChangedQuery, typeof(ToggleValueChangedEvent));
         }
     }
 }
diff --git a/com.dotsui.core/DotsUI.Controls/InputCaretSystem.cs b/com.dotsui.core/DotsUI.Controls/InputCaretSystem.cs
index adf09f9..d999c28 100644
--- a/com.dotsui.core/DotsUI.Controls/InputCaretSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/InputCaretSystem.cs
@@ -20,8 +20,8 @@ protected override void OnCreate()
                 All = new ComponentType[]
                 {
                     ComponentType.ReadOnly<InputFieldCaret>(),
-                    ComponentType.ReadWrite<ControlVertexData>(),
-                    ComponentType.ReadWrite<ControlVertexIndex>(),
+                    ComponentType.ReadWrite<ElementVertexData>(),
+                    ComponentType.ReadWrite<ElementVertexIndex>(),
                 }
             });
         }
@@ -45,8 +45,8 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                         var inputField = EntityManager.GetComponentData<InputField>(inputFieldEntity);
                         var caretState = EntityManager.GetComponentData<InputFieldCaretState>(inputFieldEntity);
 
-                        var controlVertexData = EntityManager.GetBuffer<ControlVertexData>(entity);
-                        var controlVertexIndex = EntityManager.GetBuffer<ControlVertexIndex>(entity);
+                        var controlVertexData = EntityManager.GetBuffer<ElementVertexData>(entity);
+                        var controlVertexIndex = EntityManager.GetBuffer<ElementVertexIndex>(entity);
 
                         var rect = TextUtils.GetCaretRect(inputField.Target, EntityManager, caretState.CaretPosition);
 
@@ -56,28 +56,28 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                             ? new float4(0.0f, 0.0f, 0.0f, 1.0f)
                             : new float4(0.0f, 0.0f, 0.0f, 0.0f);
 
-                        controlVertexData.Add(new ControlVertexData()
+                        controlVertexData.Add(new ElementVertexData()
                         {
                             Color = color,
                             Normal = new float3(0.0f, 0.0f, -1.0f),
                             Position = new float3(rect.Min, 0.0f),
                             TexCoord0 = new float2(0.0f)
                         });
-                        controlVertexData.Add(new ControlVertexData()
+                        controlVertexData.Add(new ElementVertexData()
                         {
                             Color = color,
                             Normal = new float3(0.0f, 0.0f, -1.0f),
                             Position = new float3(rect.Max.x, rect.Min.y, 0.0f),
                             TexCoord0 = new float2(0.0f)
                         });
-                        controlVertexData.Add(new ControlVertexData()
+                        controlVertexData.Add(new ElementVertexData()
                         {
                             Color = color,
                             Normal = new float3(0.0f, 0.0f, -1.0f),
                             Position = new float3(rect.Max.x, rect.Max.y, 0.0f),
                             TexCoord0 = new float2(0.0f)
                         });
-                        controlVertexData.Add(new ControlVertexData()
+                        controlVertexData.Add(new ElementVertexData()
                         {
                             Color = color,
                             Normal = new float3(0.0f, 0.0f, -1.0f),
diff --git a/com.dotsui.core/DotsUI.Controls/InputFieldSystem.cs b/com.dotsui.core/DotsUI.Controls/InputFieldSystem.cs
index 2ce42a2..94c218c 100644
--- a/com.dotsui.core/DotsUI.Controls/InputFieldSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/InputFieldSystem.cs
@@ -1,4 +1,5 @@
-using DotsUI.Input;
+using System.Diagnostics;
+using DotsUI.Input;
 using DotsUI.Core;
 using Unity.Burst;
 using Unity.Collections;
@@ -11,49 +12,28 @@
 namespace DotsUI.Controls
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
     public class InputFieldSystem : JobComponentSystem
     {
-        private EntityQuery m_KeyboardEventGroup;
-        private EntityQuery m_PointerEventGroup;
         private EntityQuery m_InputFieldGroup;
         private EntityQuery m_InputOnFocusQuery;
         private EntityQuery m_InputOnLostFocusQuery;
 
+        private PointerEventQuery m_PointerEventQuery;
+        private KeyboardEventQuery m_KeyboardEventQuery;
+
         private EntityArchetype m_CaretArchetype;
         private Entity m_CaretEntity;
-
-        private NativeHashMap<Entity, Entity> m_TargetToKeyboardEvent;
-        private NativeHashMap<Entity, Entity> m_TargetToPointerEvent;
         private InputHandleBarrier m_InputSystemBarrier;
 
         protected override void OnCreate()
         {
             m_CaretArchetype = EntityManager.CreateArchetype(typeof(RectTransform), typeof(Parent), typeof(WorldSpaceRect), typeof(SpriteImage), 
-                typeof(ControlVertexData), typeof(ControlVertexIndex), typeof(VertexColorValue), typeof(VertexColorMultiplier),
+                typeof(ElementVertexData), typeof(ElementVertexIndex), typeof(VertexColorValue), typeof(VertexColorMultiplier),
                 typeof(InputFieldCaret));
 
-            m_TargetToKeyboardEvent = new NativeHashMap<Entity, Entity>(4, Allocator.Persistent);
-            m_TargetToPointerEvent = new NativeHashMap<Entity, Entity>(4, Allocator.Persistent);
-
             m_InputSystemBarrier = World.GetOrCreateSystem<InputHandleBarrier>();
 
-            m_KeyboardEventGroup = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new ComponentType[]
-                {
-                    ComponentType.ReadOnly<KeyboardEvent>(),
-                    ComponentType.ReadOnly<KeyboardInputBuffer>(),
-                }
-            });
-            m_PointerEventGroup = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new ComponentType[]
-                {
-                    ComponentType.ReadOnly<PointerEvent>(),
-                    ComponentType.ReadOnly<PointerInputBuffer>(),
-                }
-            });
             m_InputFieldGroup = GetEntityQuery(new EntityQueryDesc()
             {
                 All = new ComponentType[]
@@ -62,80 +42,57 @@ protected override void OnCreate()
                     ComponentType.ReadWrite<InputFieldCaretState>()
                 }
             });
-            base.OnCreateManager();
-        }
-
-        protected override void OnDestroy()
-        {
-            m_TargetToKeyboardEvent.Dispose();
-            m_TargetToPointerEvent.Dispose();
+            m_PointerEventQuery = PointerEventQuery.Create<InputField>(EntityManager);
+            m_KeyboardEventQuery = KeyboardEventQuery.Create<InputField>(EntityManager);
         }
-        private struct EventProcessor : IJobChunk
+        
+        private struct EventProcessor : IJob
         {
-            [ReadOnly] public BufferFromEntity<KeyboardInputBuffer> KeyboardInputBufferFromEntity;
-            [ReadOnly] public BufferFromEntity<PointerInputBuffer> PointerInputBufferFromEntity;
+            [ReadOnly] public InputEventReader<KeyboardInputBuffer> KeyboardEventReader;
+            [ReadOnly] public InputEventReader<PointerInputBuffer> PointerEventReader;
             [ReadOnly] public ComponentDataFromEntity<InputFieldCaretEntityLink> InputFieldCaretLinkFromEntity;
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            public ArchetypeChunkComponentType<InputFieldCaretState> CaretStateType;
-            [ReadOnly] public ArchetypeChunkComponentType<InputField> InputFieldType;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToKeyboardEvent;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToPointerEvent;
+            [NativeDisableParallelForRestriction] public ComponentDataFromEntity<InputFieldCaretState> CaretStateFromEntity;
+            [ReadOnly] public ComponentDataFromEntity<InputField> InputFieldFromEntity;
             [WriteOnly] [NativeDisableParallelForRestriction] public BufferFromEntity<TextData> TextDataFromEntity;
             public EntityCommandBuffer.Concurrent CommandBuff;
 
             public EntityArchetype CaretArchetype;
 
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            public void Execute()
             {
-                var entityArray = chunk.GetNativeArray(EntityType);
-                var caretStateAccessor = chunk.GetNativeArray(CaretStateType);
-                var inputFieldArray = chunk.GetNativeArray(InputFieldType);
-                for (int i = 0; i < chunk.Count; i++)
+                for (int i = 0; i < PointerEventReader.EntityCount; i++)
                 {
-                    var inputFieldEntity = entityArray[i];
-                    var thisInputField = inputFieldArray[i];
-
-                    var isPointerInputPending = TargetToPointerEvent.TryGetValue(inputFieldEntity, out var pointerEventEntity);
-                    var isKeyboardInputPending =
-                        TargetToKeyboardEvent.TryGetValue(inputFieldEntity, out var eventEntity);
+                    var inputFieldEntity = PointerEventReader[i];
+                    var thisInputField = InputFieldFromEntity[inputFieldEntity];
 
-                    if (isPointerInputPending || isKeyboardInputPending)
-                    {
-                        DynamicBuffer<PointerInputBuffer> pointerInputBuffer = default;
-                        if (isPointerInputPending)
-                            pointerInputBuffer = PointerInputBufferFromEntity[pointerEventEntity];
+                    var textData = TextDataFromEntity[thisInputField.Target];
+                    CaretStateFromEntity[inputFieldEntity] = ProcessPointerInput(inputFieldEntity, textData, CaretStateFromEntity[inputFieldEntity], 0);
+                }
+                for (int i = 0; i < KeyboardEventReader.EntityCount; i++)
+                {
+                    var inputFieldEntity = KeyboardEventReader[i];
+                    var thisInputField = InputFieldFromEntity[inputFieldEntity];
 
-                        var textData = TextDataFromEntity[thisInputField.Target];
-                        int oldTextLen = textData.Length;
-
-                        // Handle selection and click events
-                        if (isPointerInputPending)
-                        {
-                            caretStateAccessor[i] = ProcessPointerInput(inputFieldEntity, pointerInputBuffer, textData, caretStateAccessor[i], chunkIndex);
-                        }
-                        if (isKeyboardInputPending)
-                        {
-                            CommandBuff.AddComponent(chunkIndex, thisInputField.Target, new DirtyElementFlag());
-                            caretStateAccessor[i] = ProcessInput(inputFieldEntity, KeyboardInputBufferFromEntity[eventEntity], textData, caretStateAccessor[i], chunkIndex);
-                            if (thisInputField.Placeholder != default)
-                            {
-                                if (textData.Length > 0)
-                                    CommandBuff.AddComponent(chunkIndex, thisInputField.Placeholder, new Disabled());
-                                else if (oldTextLen > 0 && textData.Length == 0)
-                                    CommandBuff.RemoveComponent<Disabled>(chunkIndex, thisInputField.Placeholder);
-                            }
-                        }
+                    var textData = TextDataFromEntity[thisInputField.Target];
+                    var oldTextLen = textData.Length;
 
+                    CommandBuff.AddComponent(0, thisInputField.Target, new DirtyElementFlag());
+                    CaretStateFromEntity[inputFieldEntity] = ProcessInput(inputFieldEntity, textData, CaretStateFromEntity[inputFieldEntity], 0);
+                    if (thisInputField.Placeholder != default)
+                    {
+                        if (textData.Length > 0)
+                            CommandBuff.AddComponent(0, thisInputField.Placeholder, new Disabled());
+                        else if (oldTextLen > 0 && textData.Length == 0)
+                            CommandBuff.RemoveComponent<Disabled>(0, thisInputField.Placeholder);
                     }
-
                 }
             }
 
-            private InputFieldCaretState ProcessPointerInput(Entity inputFieldEntity, DynamicBuffer<PointerInputBuffer> pointerInputBuffer, DynamicBuffer<TextData> textData, InputFieldCaretState caretState, int chunkIdx)
+            private InputFieldCaretState ProcessPointerInput(Entity inputFieldEntity, DynamicBuffer<TextData> textData, InputFieldCaretState caretState, int chunkIdx)
             {
-                for (int i = 0; i < pointerInputBuffer.Length; i++)
+                PointerEventReader.GetFirstEvent(inputFieldEntity, out var pointerEvent, out var it);
+                do
                 {
-                    var pointerEvent = pointerInputBuffer[i];
                     if (pointerEvent.EventType == PointerEventType.Selected)
                     {
                         caretState.CaretPosition = textData.Length;
@@ -143,7 +100,6 @@ private InputFieldCaretState ProcessPointerInput(Entity inputFieldEntity, Dynami
                         {
                             CaretEntity = CreateCaret(inputFieldEntity, chunkIdx)
                         });
-                        //CommandBuff.RemoveComponent(chunkIdx, caretState.CaretEntity, typeof(Disabled));
                     }
 
                     if (pointerEvent.EventType == PointerEventType.Click)
@@ -155,12 +111,14 @@ private InputFieldCaretState ProcessPointerInput(Entity inputFieldEntity, Dynami
                         CommandBuff.AddComponent(chunkIdx, inputFieldEntity, new InputFieldEndEditEvent());
                         if (InputFieldCaretLinkFromEntity.Exists(inputFieldEntity))
                         {
-                            CommandBuff.DestroyEntity(chunkIdx, InputFieldCaretLinkFromEntity[inputFieldEntity].CaretEntity);
+                            CommandBuff.DestroyEntity(chunkIdx,
+                                InputFieldCaretLinkFromEntity[inputFieldEntity].CaretEntity);
                             CommandBuff.RemoveComponent(chunkIdx, inputFieldEntity, typeof(InputFieldCaretEntityLink));
                         }
+
                         CommandBuff.AddComponent(chunkIdx, inputFieldEntity, new DirtyElementFlag());
                     }
-                }
+                } while (PointerEventReader.TryGetNextEvent(out pointerEvent, ref it));
 
                 return caretState;
             }
@@ -200,15 +158,15 @@ Entity CreateCaret(Entity inputFieldEntity, int chunkIdx)
                 return caret;
             }
 
-            private InputFieldCaretState ProcessInput(Entity inputFieldEntity, DynamicBuffer<KeyboardInputBuffer> inputBuffer,
+            private InputFieldCaretState ProcessInput(Entity inputFieldEntity,
                 DynamicBuffer<TextData> textData, InputFieldCaretState caretState, int chunkIndex)
             {
-                for (int i = 0; i < inputBuffer.Length; i++)
+                KeyboardEventReader.GetFirstEvent(inputFieldEntity, out var keyboardEvent, out var it);
+                do
                 {
-                    var key = inputBuffer[i];
-                    if (key.EventType == KeyboardEventType.Key)
+                    if (keyboardEvent.EventType == KeyboardEventType.Key)
                     {
-                        switch ((KeyCode)key.KeyCode)
+                        switch ((KeyCode) keyboardEvent.KeyCode)
                         {
                             case KeyCode.Backspace:
                                 if (caretState.CaretPosition > 0)
@@ -216,6 +174,7 @@ private InputFieldCaretState ProcessInput(Entity inputFieldEntity, DynamicBuffer
                                     textData.RemoveAt(caretState.CaretPosition - 1);
                                     caretState.CaretPosition--;
                                 }
+
                                 break;
                             case KeyCode.LeftArrow:
                                 caretState.CaretPosition = math.max(0, caretState.CaretPosition - 1);
@@ -237,108 +196,42 @@ private InputFieldCaretState ProcessInput(Entity inputFieldEntity, DynamicBuffer
                     }
                     else
                     {
-                        textData.Insert(caretState.CaretPosition, new TextData() { Value = key.Character });
+                        textData.Insert(caretState.CaretPosition, new TextData() {Value = keyboardEvent.Character});
                         caretState.CaretPosition++;
                     }
-                }
+                } while (KeyboardEventReader.TryGetNextEvent(out keyboardEvent, ref it));
                 return caretState;
             }
 
         }
 
-
-        [BurstCompile]
-        struct CreateTargetToKeyboardEvent : IJobChunk
-        {
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            [ReadOnly] public ArchetypeChunkComponentType<KeyboardEvent> KbdEventType;
-            [WriteOnly] public NativeHashMap<Entity, Entity>.ParallelWriter TargetToEvent;
-
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
-            {
-                var entityArray = chunk.GetNativeArray(EntityType);
-                var eventArray = chunk.GetNativeArray(KbdEventType);
-                for (int i = 0; i < chunk.Count; i++)
-                {
-                    TargetToEvent.TryAdd(eventArray[i].Target, entityArray[i]);
-                }
-            }
-        }
-        [BurstCompile]
-        struct CreateTargetToPointerEvent : IJobChunk
-        {
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            [ReadOnly] public ArchetypeChunkComponentType<PointerEvent> PointerEventType;
-            [WriteOnly] public NativeHashMap<Entity, Entity>.ParallelWriter TargetToEvent;
-
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
-            {
-                var entityArray = chunk.GetNativeArray(EntityType);
-                var eventArray = chunk.GetNativeArray(PointerEventType);
-                for (int i = 0; i < chunk.Count; i++)
-                {
-                    TargetToEvent.TryAdd(eventArray[i].Target, entityArray[i]);
-                }
-            }
-        }
-
-
         protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
-            if (m_KeyboardEventGroup.CalculateEntityCount() > 0 || m_PointerEventGroup.CalculateEntityCount() > 0)
+            var keyboardEventReader = m_KeyboardEventQuery.CreateKeyboardEventReader(Allocator.TempJob);
+            var pointerEventReader = m_PointerEventQuery.CreatePointerEventReader(Allocator.TempJob);
+            if (keyboardEventReader.EntityCount > 0 || pointerEventReader.EntityCount > 0)
             {
-                m_TargetToKeyboardEvent.Clear();
-                m_TargetToPointerEvent.Clear();
-                var entityType = GetArchetypeChunkEntityType();
                 using(new Profiling.ProfilerSample("ScheduleJobs"))
                 {
-                    CreateTargetToKeyboardEvent createTargetToKeyboardEvent = new CreateTargetToKeyboardEvent()
-                    {
-                        EntityType = entityType,
-                        KbdEventType = GetArchetypeChunkComponentType<KeyboardEvent>(true),
-                        TargetToEvent = m_TargetToKeyboardEvent.AsParallelWriter()
-                    };
-                    inputDeps = createTargetToKeyboardEvent.Schedule(m_KeyboardEventGroup, inputDeps);
-                    CreateTargetToPointerEvent createTargetToPointerEvent = new CreateTargetToPointerEvent()
-                    {
-                        EntityType = entityType,
-                        PointerEventType = GetArchetypeChunkComponentType<PointerEvent>(true),
-                        TargetToEvent = m_TargetToPointerEvent.AsParallelWriter()
-                    };
-                    inputDeps = createTargetToPointerEvent.Schedule(m_PointerEventGroup, inputDeps);
                     EventProcessor inputEventProcessor = new EventProcessor()
                     {
-                        KeyboardInputBufferFromEntity = GetBufferFromEntity<KeyboardInputBuffer>(true),
-                        PointerInputBufferFromEntity = GetBufferFromEntity<PointerInputBuffer>(true),
+                        PointerEventReader = pointerEventReader,
+                        KeyboardEventReader = keyboardEventReader,
                         InputFieldCaretLinkFromEntity = GetComponentDataFromEntity<InputFieldCaretEntityLink>(true),
-                        EntityType = entityType,
-                        CaretStateType = GetArchetypeChunkComponentType<InputFieldCaretState>(),
-                        InputFieldType = GetArchetypeChunkComponentType<InputField>(),
+                        CaretStateFromEntity = GetComponentDataFromEntity<InputFieldCaretState>(),
+                        InputFieldFromEntity = GetComponentDataFromEntity<InputField>(),
                         TextDataFromEntity = GetBufferFromEntity<TextData>(),
-                        TargetToKeyboardEvent = m_TargetToKeyboardEvent,
-                        TargetToPointerEvent = m_TargetToPointerEvent,
                         CommandBuff = m_InputSystemBarrier.CreateCommandBuffer().ToConcurrent(),
                         CaretArchetype = m_CaretArchetype
                     };
-                    inputDeps = inputEventProcessor.Schedule(m_InputFieldGroup, inputDeps);
+                    inputDeps = inputEventProcessor.Schedule(inputDeps);
                     m_InputSystemBarrier.AddJobHandleForProducer(inputDeps);
                 }
             }
 
+            inputDeps = keyboardEventReader.Dispose(inputDeps);
+            inputDeps = pointerEventReader.Dispose(inputDeps);
             return inputDeps;
         }
-
-        private void CreateCaretState(Entity focusedEntity)
-        {
-            EntityManager.AddComponentData(focusedEntity, new InputFieldCaretState()
-            {
-                CaretPosition = EntityManager.GetBuffer<TextData>(focusedEntity).Length,
-            });
-            m_CaretEntity = EntityManager.CreateEntity(m_CaretArchetype);
-            EntityManager.SetComponentData(m_CaretEntity, new Parent()
-            {
-                Value = focusedEntity
-            });
-        }
     }
 }
diff --git a/com.dotsui.core/DotsUI.Controls/ScrollBarHandleSystem.cs b/com.dotsui.core/DotsUI.Controls/ScrollBarHandleSystem.cs
index 4af1922..180e8bb 100644
--- a/com.dotsui.core/DotsUI.Controls/ScrollBarHandleSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/ScrollBarHandleSystem.cs
@@ -10,63 +10,61 @@
 namespace DotsUI.Controls
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
-    class ScrollBarHandleSystem : PointerInputComponentSystem<ScrollBar>
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
+    class ScrollBarHandleSystem : JobComponentSystem
     {
         private EntityQuery m_ScrollBarQuery;
         private InputHandleBarrier m_Barrier;
+        private PointerEventQuery m_EventQuery;
 
-        protected override void OnCreateInput()
+        protected override void OnCreate()
         {
             m_ScrollBarQuery = GetEntityQuery(ComponentType.ReadOnly<ScrollBar>());
             RequireForUpdate(m_ScrollBarQuery);
+            m_EventQuery = PointerEventQuery.Create<ScrollBar>(EntityManager);
             m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
         }
 
-        protected override void OnDestroyInput()
+        protected override void OnDestroy()
         {
         }
 
         [BurstCompile]
-        struct ScrollBarHandleJob : IJobChunk
+        struct ScrollBarHandleJob : IJob
         {
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            public ArchetypeChunkComponentType<ScrollBar> ScrollBarType;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToEvent;
-            [ReadOnly] public BufferFromEntity<PointerInputBuffer> PointerBufferFromEntity;
+            public ComponentDataFromEntity<ScrollBar> ScrollBarFromEntity;
+            [ReadOnly] public InputEventReader<PointerInputBuffer> EventReader;
             [ReadOnly] public ComponentDataFromEntity<ScrollRect> ScrollRectFromEntity;
-            public AddFlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
+            public FlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
 
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            public void Execute()
             {
-                var scrollBarArray = chunk.GetNativeArray(ScrollBarType);
-                var entityArray = chunk.GetNativeArray(EntityType);
-
-                for (int i = 0; i < chunk.Count; i++)
+                for (int i = 0; i < EventReader.EntityCount; i++)
                 {
-                    var scrollBar = scrollBarArray[i];
-                    if (TargetToEvent.TryGetValue(entityArray[i], out var eventEntity))
-                    {
-                        var pointerBuff = PointerBufferFromEntity[eventEntity];
-                        for (int j = 0; j < pointerBuff.Length; j++)
-                            scrollBarArray[i] = HandleInputEvent(entityArray[i], scrollBar, pointerBuff[j]);
-                    }
+                    var entity = EventReader[i];
+                    ScrollBarFromEntity[entity] = HandleInputEvent(entity, ScrollBarFromEntity[entity]);
                 }
             }
 
-            private ScrollBar HandleInputEvent(Entity scrollBarEntity, ScrollBar scrollBar, PointerInputBuffer pointerInput)
+            private ScrollBar HandleInputEvent(Entity scrollBarEntity, ScrollBar scrollBar)
             {
-                if (pointerInput.EventType == PointerEventType.Drag)
+                EventReader.GetFirstEvent(scrollBarEntity, out var pointerEvent, out var it);
+                do
                 {
+                    if(pointerEvent.EventType != PointerEventType.Drag)
+                        continue;
+                    
                     var scrollRect = ScrollRectFromEntity[scrollBar.ParentScrollRect];
                     float value = scrollBar.Value;
                     if (scrollRect.HorizontalBar == scrollBarEntity)
                     {
-                        value = math.saturate(scrollBar.Value + pointerInput.EventData.Delta.x * scrollBar.HandleDragSensitivity);
+                        value = math.saturate(scrollBar.Value +
+                                              pointerEvent.EventData.Delta.x * scrollBar.HandleDragSensitivity);
                     }
                     else if (scrollRect.VerticalBar == scrollBarEntity)
                     {
-                        value = math.saturate(scrollBar.Value + pointerInput.EventData.Delta.y * scrollBar.HandleDragSensitivity);
+                        value = math.saturate(scrollBar.Value +
+                                              pointerEvent.EventData.Delta.y * scrollBar.HandleDragSensitivity);
                     }
 
                     if (math.abs(value - scrollBar.Value) >= scrollBar.HandleDragSensitivity)
@@ -75,25 +73,25 @@ private ScrollBar HandleInputEvent(Entity scrollBarEntity, ScrollBar scrollBar,
                     }
 
                     scrollBar.Value = value;
-                }
+                } while (EventReader.TryGetNextEvent(out pointerEvent, ref it));
 
                 return scrollBar;
             }
         }
 
-        protected override JobHandle OnUpdateInput(JobHandle inputDeps, NativeHashMap<Entity, Entity> targetToEvent, BufferFromEntity<PointerInputBuffer> pointerBufferFromEntity)
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
+            var eventReader = m_EventQuery.CreatePointerEventReader(Allocator.TempJob);
             ScrollBarHandleJob scrollBarJob = new ScrollBarHandleJob()
             {
-                EntityType = GetArchetypeChunkEntityType(),
-                ScrollBarType = GetArchetypeChunkComponentType<ScrollBar>(),
-                TargetToEvent = targetToEvent,
-                PointerBufferFromEntity = pointerBufferFromEntity,
+                ScrollBarFromEntity = GetComponentDataFromEntity<ScrollBar>(),
+                EventReader = eventReader,
                 ScrollRectFromEntity = GetComponentDataFromEntity<ScrollRect>(true),
-                AddFlagCommandBuff = m_Barrier.CreateAddFlagComponentCommandBuffer<DirtyElementFlag>().AsParallelWriter()
+                AddFlagCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<DirtyElementFlag>().AsParallelWriter()
             };
-            inputDeps = scrollBarJob.Schedule(m_ScrollBarQuery, inputDeps);
+            inputDeps = scrollBarJob.Schedule(inputDeps);
             m_Barrier.AddJobHandleForProducer(inputDeps);
+            inputDeps = eventReader.Dispose(inputDeps);
             return inputDeps;
         }
     }
diff --git a/com.dotsui.core/DotsUI.Controls/ScrollRectDragSystem.cs b/com.dotsui.core/DotsUI.Controls/ScrollRectDragSystem.cs
index aeb0483..f95c46c 100644
--- a/com.dotsui.core/DotsUI.Controls/ScrollRectDragSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/ScrollRectDragSystem.cs
@@ -10,42 +10,40 @@
 namespace DotsUI.Controls
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
-    class ScrollRectDragSystem : PointerInputComponentSystem<ScrollRect>
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
+    class ScrollRectDragSystem : JobComponentSystem
     {
         private EntityQuery m_ScrollRectQuery;
+        private PointerEventQuery m_ScrollEventQuery;
         private InputHandleBarrier m_Barrier;
 
-        protected override void OnCreateInput()
+        protected override void OnCreate()
         {
             m_ScrollRectQuery = GetEntityQuery(ComponentType.ReadOnly<ScrollRect>());
+            m_ScrollEventQuery = PointerEventQuery.Create<ScrollRect>(EntityManager);
             m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
         }
 
         [BurstCompile]
-        struct ScrollBarHandleJob : IJobChunk
+        struct ScrollBarHandleJob : IJob
         {
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            [ReadOnly] public ArchetypeChunkComponentType<ScrollRect> ScrollRectType;
+            [ReadOnly] public ComponentDataFromEntity<ScrollRect> ScrollRectFromEntity;
             [NativeDisableParallelForRestriction] public ComponentDataFromEntity<ScrollBar> ScrollBarFormEntity;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToEvent;
-            [ReadOnly] public BufferFromEntity<PointerInputBuffer> PointerBufferFromEntity;
-            public AddFlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
+            public FlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
+            [ReadOnly]
+            public InputEventReader<PointerInputBuffer> EventReader;
 
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            public void Execute()
             {
-                var scrollRectArray = chunk.GetNativeArray(ScrollRectType);
-                var entityArray = chunk.GetNativeArray(EntityType);
-
-                for (int i = 0; i < chunk.Count; i++)
+                for (int i = 0; i < EventReader.EntityCount; i++)
                 {
-                    if (TargetToEvent.TryGetValue(entityArray[i], out var eventEntity))
+                    var target = EventReader[i];
+                    EventReader.GetFirstEvent(target, out var pointerEvent, out var it);
+                    var scrollRect = ScrollRectFromEntity[target];
+                    do
                     {
-                        var scrollRect = scrollRectArray[i];
-                        var pointerBuff = PointerBufferFromEntity[eventEntity];
-                        for (int j = 0; j < pointerBuff.Length; j++)
-                            HandleInputEvent(entityArray[i], scrollRect, pointerBuff[j]);
-                    }
+                        HandleInputEvent(target, scrollRect, pointerEvent);
+                    } while (EventReader.TryGetNextEvent(out pointerEvent, ref it));
                 }
             }
 
@@ -76,26 +74,26 @@ private void HandleInputEvent(Entity scrollRectEntity, ScrollRect scrollRect, Po
             }
         }
 
-        protected override JobHandle OnUpdateInput(JobHandle inputDeps, NativeHashMap<Entity, Entity> targetToEvent, BufferFromEntity<PointerInputBuffer> pointerBufferFromEntity)
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
-            var commandBuff = m_Barrier.CreateAddFlagComponentCommandBuffer<DirtyElementFlag>();
-            ScrollBarHandleJob scrollRectDragJob = new ScrollBarHandleJob()
+            var commandBuff = m_Barrier.CreateFlagComponentCommandBuffer<DirtyElementFlag>();
+            var eventReader = m_ScrollEventQuery.CreatePointerEventReader(Allocator.TempJob);
+            if (eventReader.EntityCount > 0)
             {
-                AddFlagCommandBuff = commandBuff.AsParallelWriter(),
-                EntityType = GetArchetypeChunkEntityType(),
-                PointerBufferFromEntity = GetBufferFromEntity<PointerInputBuffer>(true),
-                ScrollBarFormEntity = GetComponentDataFromEntity<ScrollBar>(),
-                ScrollRectType = GetArchetypeChunkComponentType<ScrollRect>(true),
-                TargetToEvent = targetToEvent
+                ScrollBarHandleJob scrollRectDragJob = new ScrollBarHandleJob()
+                {
+                    AddFlagCommandBuff = commandBuff.AsParallelWriter(),
+                    EventReader = eventReader,
+                    ScrollBarFormEntity = GetComponentDataFromEntity<ScrollBar>(),
+                    ScrollRectFromEntity = GetComponentDataFromEntity<ScrollRect>(true),
 
-            };
-            inputDeps = scrollRectDragJob.Schedule(m_ScrollRectQuery, inputDeps);
-            m_Barrier.AddJobHandleForProducer(inputDeps);
-            return inputDeps;
-        }
+                };
+                inputDeps = scrollRectDragJob.Schedule(inputDeps);
+                m_Barrier.AddJobHandleForProducer(inputDeps);
+            }
 
-        protected override void OnDestroyInput()
-        {
+            inputDeps = eventReader.Dispose(inputDeps);
+            return inputDeps;
         }
     }
 }
diff --git a/com.dotsui.core/DotsUI.Controls/ScrollRectTransformSystem.cs b/com.dotsui.core/DotsUI.Controls/ScrollRectTransformSystem.cs
index a715911..b506f7b 100644
--- a/com.dotsui.core/DotsUI.Controls/ScrollRectTransformSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/ScrollRectTransformSystem.cs
@@ -49,6 +49,7 @@ struct UpdateScrollRectData : IJobChunk
             [NativeDisableParallelForRestriction] public ComponentDataFromEntity<ElementScale> ElementScaleFromEntity;
             [NativeDisableParallelForRestriction] public ComponentDataFromEntity<WorldSpaceMask> WorldSpaceMaskFromEntity;
             [ReadOnly] public ComponentDataFromEntity<RectMask> RectMaskFromEntity;
+            [ReadOnly] public ComponentDataFromEntity<Disabled> DisabledFromEntity;
 
             public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
             {
@@ -56,6 +57,7 @@ public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
                 NativeArray<Entity> scrollEntity = chunk.GetNativeArray(EntityType);
                 var rebuildContext = new HierarchyRebuildContext()
                 {
+                    DisabledFromEntity = DisabledFromEntity,
                     ChildrenFromEntity = ChildrenFromEntity,
                     WorldSpaceRectFromEntity = WorldSpaceRectFromEntity,
                     RectTransformFromEntity = RectTransformFromEntity,
@@ -207,6 +209,7 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                 ScrollRectType = GetArchetypeChunkComponentType<ScrollRect>(),
 
                 WorldSpaceRectFromEntity = GetComponentDataFromEntity<WorldSpaceRect>(),
+                DisabledFromEntity = GetComponentDataFromEntity<Disabled>(),
                 RectTransformFromEntity = GetComponentDataFromEntity<RectTransform>(),
                 ScrollBarFromEntity = GetComponentDataFromEntity<ScrollBar>(),
                 ChildrenFromEntity = GetBufferFromEntity<Child>(),
diff --git a/com.dotsui.core/DotsUI.Controls/SliderInputSystem.cs b/com.dotsui.core/DotsUI.Controls/SliderInputSystem.cs
index 6d93996..3c195d7 100644
--- a/com.dotsui.core/DotsUI.Controls/SliderInputSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/SliderInputSystem.cs
@@ -11,49 +11,54 @@
 namespace DotsUI.Controls
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
-    class SliderInputSystem : PointerInputComponentSystem<Slider>
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
+    class SliderInputSystem : JobComponentSystem
     {
         private EntityQuery m_SliderQuery;
+        private PointerEventQuery m_PointerQuery;
         private InputHandleBarrier m_Barrier;
 
+
+        protected override void OnCreate()
+        {
+            m_SliderQuery = GetEntityQuery(typeof(Slider));
+            m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
+            m_PointerQuery = PointerEventQuery.Create<Slider>(EntityManager);
+        }
+
+        protected override void OnDestroy()
+        {
+        }
+
         [BurstCompile]
-        struct SliderInputJob : IJobChunk
+        struct SliderInputJob : IJob
         {
-            public ArchetypeChunkComponentType<Slider> SliderComponentType;
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            public AddFlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
-            public AddFlagComponentCommandBuffer.ParallelWriter AddOnChangeFlagCommandBuff;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToEvent;
+            public ComponentDataFromEntity<Slider> SliderComponentFromEntity;
+            public FlagComponentCommandBuffer.ParallelWriter AddFlagCommandBuff;
+            public FlagComponentCommandBuffer.ParallelWriter AddOnChangeFlagCommandBuff;
             [ReadOnly] public ComponentDataFromEntity<WorldSpaceRect> WorldSpaceRectFromEntity;
-            [ReadOnly] public BufferFromEntity<PointerInputBuffer> PointerBufferFromEntity;
+            [ReadOnly] public InputEventReader<PointerInputBuffer> EventReader;
             [ReadOnly] public ComponentDataFromEntity<Parent> ParentFromEntity;
 
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            public void Execute()
             {
-                var sliderArray = chunk.GetNativeArray(SliderComponentType);
-                var entityArray = chunk.GetNativeArray(EntityType);
-                for (int i = 0; i < sliderArray.Length; i++)
+                for (int i = 0; i < EventReader.EntityCount; i++)
                 {
-                    if (TargetToEvent.TryGetValue(entityArray[i], out var eventEntity))
-                    {
-                        sliderArray[i] = HandleEvents(sliderArray[i], entityArray[i], eventEntity);
-                    }
+                    var entity = EventReader[i];
+                    SliderComponentFromEntity[entity] = HandleEvents(SliderComponentFromEntity[entity], entity);
                 }
             }
 
-            private Slider HandleEvents(Slider slider, Entity entity, Entity eventEntity)
+            private Slider HandleEvents(Slider slider, Entity entity)
             {
-                var pointerBuffer = PointerBufferFromEntity[eventEntity];
-                for (int i = 0; i < pointerBuffer.Length; i++)
+                EventReader.GetFirstEvent(entity, out var pointerEvent, out var it);
+                do
                 {
-                    var eventData = pointerBuffer[i];
-                    if (eventData.EventType == PointerEventType.Down)
-                        OnPointerDown(ref slider, entity, eventData);
-                    else if (eventData.EventType == PointerEventType.Drag)
-                        OnDrag(ref slider, entity, eventData);
-                }
-
+                    if (pointerEvent.EventType == PointerEventType.Down)
+                        OnPointerDown(ref slider, entity, pointerEvent);
+                    else if (pointerEvent.EventType == PointerEventType.Drag)
+                        OnDrag(ref slider, entity, pointerEvent);
+                } while (EventReader.TryGetNextEvent(out pointerEvent, ref it));
                 return slider;
             }
 
@@ -97,32 +102,26 @@ private void MoveValueTo(ref Slider slider, Entity entity, float2 normalizedLoca
             }
         }
 
-        protected override JobHandle OnUpdateInput(JobHandle inputDeps, NativeHashMap<Entity, Entity> targetToEvent, BufferFromEntity<PointerInputBuffer> pointerBufferFromEntity)
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
-            SliderInputJob sliderJob = new SliderInputJob()
+            var eventReader = m_PointerQuery.CreatePointerEventReader(Allocator.TempJob);
+            if (eventReader.EntityCount > 0)
             {
-                SliderComponentType = GetArchetypeChunkComponentType<Slider>(),
-                EntityType = GetArchetypeChunkEntityType(),
-                AddFlagCommandBuff = m_Barrier.CreateAddFlagComponentCommandBuffer<DirtyElementFlag>().AsParallelWriter(),
-                AddOnChangeFlagCommandBuff = m_Barrier.CreateAddFlagComponentCommandBuffer<SliderValueChangedEvent>().AsParallelWriter(),
-                TargetToEvent = targetToEvent,
-                WorldSpaceRectFromEntity = GetComponentDataFromEntity<WorldSpaceRect>(true),
-                PointerBufferFromEntity = GetBufferFromEntity<PointerInputBuffer>(true),
-                ParentFromEntity = GetComponentDataFromEntity<Parent>(true)
-            };
-            inputDeps = sliderJob.Schedule(m_SliderQuery, inputDeps);
-            m_Barrier.AddJobHandleForProducer(inputDeps);
-            return inputDeps;
-        }
-
-        protected override void OnCreateInput()
-        {
-            m_SliderQuery = GetEntityQuery(typeof(Slider));
-            m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
-        }
+                SliderInputJob sliderJob = new SliderInputJob()
+                {
+                    SliderComponentFromEntity = GetComponentDataFromEntity<Slider>(),
+                    AddFlagCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<DirtyElementFlag>().AsParallelWriter(),
+                    AddOnChangeFlagCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<SliderValueChangedEvent>().AsParallelWriter(),
+                    WorldSpaceRectFromEntity = GetComponentDataFromEntity<WorldSpaceRect>(true),
+                    EventReader = eventReader,
+                    ParentFromEntity = GetComponentDataFromEntity<Parent>(true)
+                };
+                inputDeps = sliderJob.Schedule(inputDeps);
+                m_Barrier.AddJobHandleForProducer(inputDeps);
+            }
 
-        protected override void OnDestroyInput()
-        {
+            inputDeps = eventReader.Dispose(inputDeps);
+            return inputDeps;
         }
     }
 }
diff --git a/com.dotsui.core/DotsUI.Controls/SliderTransformSystem.cs b/com.dotsui.core/DotsUI.Controls/SliderTransformSystem.cs
index 4d9a96d..541291e 100644
--- a/com.dotsui.core/DotsUI.Controls/SliderTransformSystem.cs
+++ b/com.dotsui.core/DotsUI.Controls/SliderTransformSystem.cs
@@ -17,7 +17,7 @@ class SliderTransformSystem : ControlRectTransformRebuildSystem
         protected override void OnCreate()
         {
             m_SliderQuery = GetEntityQuery(ComponentType.ReadOnly<Slider>(), ComponentType.ReadWrite<WorldSpaceRect>());
-            m_SliderQuery.SetFilterChanged(typeof(Slider));
+            m_SliderQuery.SetChangedVersionFilter(typeof(Slider));
             RequireForUpdate(m_SliderQuery);
         }
 
diff --git a/com.dotsui.core/DotsUI.Controls/Toggle.cs b/com.dotsui.core/DotsUI.Controls/Toggle.cs
new file mode 100644
index 0000000..8c0727b
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Controls/Toggle.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Entities;
+
+namespace DotsUI.Controls
+{
+    public struct Toggle : IComponentData
+    {
+        public bool IsOn;
+        public Entity TargetGraphic;
+        public Entity Group;
+    }
+
+    public struct ToggleGroup : IComponentData
+    {
+
+    }
+
+    public struct ToggleValueChangedEvent : IComponentData
+    {
+
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Input/InputComponentSystem.cs.meta b/com.dotsui.core/DotsUI.Controls/Toggle.cs.meta
similarity index 83%
rename from com.dotsui.core/DotsUI.Input/InputComponentSystem.cs.meta
rename to com.dotsui.core/DotsUI.Controls/Toggle.cs.meta
index b1f5931..2171154 100644
--- a/com.dotsui.core/DotsUI.Input/InputComponentSystem.cs.meta
+++ b/com.dotsui.core/DotsUI.Controls/Toggle.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 0b0bb6f30d8ae674aa12b81bd895f768
+guid: 3870ee9e2edfe504f98461e09368fc7f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs b/com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs
new file mode 100644
index 0000000..dc55274
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs
@@ -0,0 +1,89 @@
+using DotsUI.Core;
+using DotsUI.Core.Utils;
+using DotsUI.Input;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Jobs;
+
+namespace DotsUI.Controls
+{
+    [UpdateInGroup(typeof(InputSystemGroup))]
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
+    class ToggleInputSystem : JobComponentSystem
+    {
+        private EntityQuery m_ToggleQuery;
+        private PointerEventQuery m_EventQuery;
+        private InputHandleBarrier m_Barrier;
+
+        protected override void OnCreate()
+        {
+            m_ToggleQuery = GetEntityQuery(typeof(Toggle));
+            m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
+            m_EventQuery = PointerEventQuery.Create<Toggle>(EntityManager);
+        }
+
+        struct UpdateToggle : IJob
+        {
+            public ComponentDataFromEntity<Toggle> ToggleComponentFromEntity;
+            public InputEventReader<PointerInputBuffer> EventReader;
+            public FlagComponentCommandBuffer.ParallelWriter DisableCommandBuff;
+            public FlagComponentCommandBuffer.ParallelWriter RebuildMeshCommandBuff;
+            public FlagComponentCommandBuffer.ParallelWriter ToggleEventCommandBuff;
+
+            public void Execute()
+            {
+                for (int i = 0; i < EventReader.EntityCount; i++)
+                {
+                    var entity = EventReader[i];
+                    var toggle = ToggleComponentFromEntity[entity];
+                    ToggleComponentFromEntity[entity] = HandleEvents(entity, toggle);
+                }
+            }
+
+            private Toggle HandleEvents(Entity entity, Toggle toggle)
+            {
+                var ret = toggle;
+                EventReader.GetFirstEvent(entity, out var pointerEvent, out var it);
+                do
+                {
+                    if ((pointerEvent.EventType & PointerEventType.Click) != 0)
+                    {
+                        ret.IsOn = !ret.IsOn;
+                    }
+                } while (EventReader.TryGetNextEvent(out pointerEvent, ref it));
+
+                if (ret.IsOn != toggle.IsOn)
+                {
+                    if(ret.IsOn)
+                        DisableCommandBuff.TryRemove(toggle.TargetGraphic);
+                    else
+                        DisableCommandBuff.TryAdd(toggle.TargetGraphic);
+                    RebuildMeshCommandBuff.TryAdd(entity);
+                    ToggleEventCommandBuff.TryAdd(entity);
+                }
+
+                return ret;
+            }
+        }
+
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
+        {
+            var eventReader = m_EventQuery.CreatePointerEventReader(Allocator.TempJob);
+            if (eventReader.EntityCount > 0)
+            {
+                UpdateToggle toggleJob = new UpdateToggle()
+                {
+                    ToggleComponentFromEntity = GetComponentDataFromEntity<Toggle>(),
+                    EventReader = eventReader,
+                    DisableCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<Disabled>().AsParallelWriter(),
+                    RebuildMeshCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<DirtyElementFlag>().AsParallelWriter(),
+                    ToggleEventCommandBuff = m_Barrier.CreateFlagComponentCommandBuffer<ToggleValueChangedEvent>().AsParallelWriter(),
+                };
+                inputDeps = toggleJob.Schedule(inputDeps);
+                m_Barrier.AddJobHandleForProducer(inputDeps);
+            }
+            inputDeps = eventReader.Dispose(inputDeps);
+            return inputDeps;
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Input/InputDataCleanup.cs.meta b/com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs.meta
similarity index 83%
rename from com.dotsui.core/DotsUI.Input/InputDataCleanup.cs.meta
rename to com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs.meta
index 6d072f1..7b0fea9 100644
--- a/com.dotsui.core/DotsUI.Input/InputDataCleanup.cs.meta
+++ b/com.dotsui.core/DotsUI.Controls/ToggleInputSystem.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3156b2f57f207df4893d3a6d6b1a6759
+guid: 5bfac0dc0aa375146b9e580ed965c30d
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/com.dotsui.core/DotsUI.Core/CanvasComponent.cs b/com.dotsui.core/DotsUI.Core/CanvasComponent.cs
index 2ccfdcd..27a8341 100644
--- a/com.dotsui.core/DotsUI.Core/CanvasComponent.cs
+++ b/com.dotsui.core/DotsUI.Core/CanvasComponent.cs
@@ -14,27 +14,24 @@ public struct CanvasConstantPhysicalSizeScaler : IComponentData
         public float Factor;
     }
 
-    public struct CanvasScreenSize : IComponentData
+    public struct CanvasConstantPixelSizeScaler : IComponentData
     {
-        public int2 Value;
+
     }
 
-    public struct CanvasConstantPixelSizeScaler : IComponentData
+    public struct CanvasSize : IComponentData
     {
-
+        public int2 Value;
     }
     public struct CanvasSortLayer : IComponentData
     {
-        /// <summary>
-        /// </summary>
         public int Value;
     }
     /// <summary>
-    /// 16 seems like a quite big buffer, but it's enough to store 9-slice sprite vertices.
-    /// It is the most common sprite type used in UI. I noticed performance increase compared to smaller buffers
+    /// 
     /// </summary>
     [InternalBufferCapacity(0)]
-    public struct ControlVertexData : IBufferElementData
+    public struct ElementVertexData : IBufferElementData
     {
         public float3 Position;
         public float3 Normal;
@@ -42,12 +39,15 @@ public struct ControlVertexData : IBufferElementData
         public float2 TexCoord0;
         public float2 TexCoord1;
     }
-    [InternalBufferCapacity(0)]    // 54 is the worst case scenario for 9-slice sprite
-    public struct ControlVertexIndex : IBufferElementData
+    /// <summary>
+    /// 
+    /// </summary>
+    [InternalBufferCapacity(0)]
+    public struct ElementVertexIndex : IBufferElementData
     {
         public int Value;
-        public static implicit operator ControlVertexIndex(int v) { return new ControlVertexIndex { Value = v }; }
-        public static implicit operator int(ControlVertexIndex v) { return v.Value; }
+        public static implicit operator ElementVertexIndex(int v) { return new ElementVertexIndex { Value = v }; }
+        public static implicit operator int(ElementVertexIndex v) { return v.Value; }
     }
 
     [StructLayout(LayoutKind.Sequential)]
@@ -59,7 +59,7 @@ public struct MeshVertex : IBufferElementData
         public float2 TexCoord0;
         public float2 TexCoord1;
 
-        public static implicit operator MeshVertex(ControlVertexData v)
+        public static implicit operator MeshVertex(ElementVertexData v)
         {
             return new MeshVertex
             {
@@ -70,9 +70,9 @@ public static implicit operator MeshVertex(ControlVertexData v)
                 TexCoord1 = v.TexCoord1
             };
         }
-        public static implicit operator ControlVertexData(MeshVertex v)
+        public static implicit operator ElementVertexData(MeshVertex v)
         {
-            return new ControlVertexData()
+            return new ElementVertexData()
             {
                 Position = v.Position,
                 Normal = v.Normal,
diff --git a/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs b/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs
new file mode 100644
index 0000000..14e6387
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Entities;
+
+namespace DotsUI.Core
+{
+    /// <summary>
+    /// This flag indicated structural change in the canvas hierarchy.
+    /// Structural change means updated parent/child relation.
+    /// </summary>
+    struct CanvasStructuralChange : IComponentData
+    {
+    }
+
+    /// <summary>
+    /// This flag indicates layout change of the canvas.
+    /// It's attached to the canvas when any of the canvas children requires update
+    /// </summary>
+    struct CanvasLayoutChange : IComponentData
+    {
+
+    }
+
+    /// <summary>
+    /// Added to the canvas when any child needs vertex data update (in example color update)
+    /// </summary>
+    struct CanvasVertexDataChange : IComponentData
+    {
+
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs.meta b/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs.meta
new file mode 100644
index 0000000..ca37db4
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/CanvasFlagComponents.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 265ffed5a6d7b8b4f9f4d83bc2460312
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Core/MeshBatchSystem.cs b/com.dotsui.core/DotsUI.Core/MeshBatchSystem.cs
index aa0b636..ca6948c 100644
--- a/com.dotsui.core/DotsUI.Core/MeshBatchSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/MeshBatchSystem.cs
@@ -31,8 +31,8 @@ private struct MeshBatching : IJobChunk
             [ReadOnly] public NativeHashMap<Entity, MaterialInfo> EntityToMaterial;
 
 
-            [ReadOnly] public BufferFromEntity<ControlVertexData> VerticesFromEntity;
-            [ReadOnly] public BufferFromEntity<ControlVertexIndex> TrianglesFromEntity;
+            [ReadOnly] public BufferFromEntity<ElementVertexData> VerticesFromEntity;
+            [ReadOnly] public BufferFromEntity<ElementVertexIndex> TrianglesFromEntity;
 
             [NativeDisableContainerSafetyRestriction]
             [WriteOnly] public ArchetypeChunkBufferType<MeshVertex> VertexType;
@@ -89,35 +89,36 @@ private void PopulateMesh(Entity entity, ref DynamicBuffer<MeshVertex> vertices,
                     material.Id = -1;
                 }
 
-                if (m_CurrentMaterialId != material.Id)
+                int offset = triangles.Length;
+                int startIndex = vertices.Length;
+                if(VertexPointerFromEntity.Exists(entity))
+                    VertexPointerFromEntity[entity] = new ElementVertexPointerInMesh(){VertexPointer = startIndex};
+                var writtenIndices = Populate(entity, ref vertices, ref triangles, startIndex);
+
+                if (m_CurrentMaterialId != material.Id && writtenIndices > 0)
                 {
                     subMeshes.Add(new SubMeshInfo()
                     {
-                        Offset = triangles.Length,
+                        Offset = offset,
                         MaterialId = material.Id,
                         MaterialType = material.Type
                     });
                     m_CurrentMaterialId = material.Id;
                 }
-
-
-                int startIndex = vertices.Length;
-                if(VertexPointerFromEntity.Exists(entity))
-                    VertexPointerFromEntity[entity] = new ElementVertexPointerInMesh(){VertexPointer = startIndex};
-                Populate(entity, ref vertices, ref triangles, startIndex);
             }
 
-            private void Populate(Entity entity, ref DynamicBuffer<MeshVertex> vertices, ref DynamicBuffer<MeshVertexIndex> triangles, int startIndex)
+            private int Populate(Entity entity, ref DynamicBuffer<MeshVertex> vertices, ref DynamicBuffer<MeshVertexIndex> triangles, int startIndex)
             {
-                var textVertices = VerticesFromEntity[entity];
-                var textIndices = TrianglesFromEntity[entity];
+                var elementTriangles = VerticesFromEntity[entity];
+                var elementIndices = TrianglesFromEntity[entity];
 
-                for (int i = 0; i < textIndices.Length; i++)
+                for (int i = 0; i < elementIndices.Length; i++)
                     triangles.Add(new MeshVertexIndex()
                     {
-                        Value = textIndices[i].Value + startIndex
+                        Value = elementIndices[i].Value + startIndex
                     });
-                vertices.AddRange(textVertices.Reinterpret<MeshVertex>().AsNativeArray());
+                vertices.AddRange(elementTriangles.Reinterpret<MeshVertex>().AsNativeArray());
+                return elementIndices.Length;
             }
         }
 
@@ -175,8 +176,8 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
             inputDeps = UpdateBatchIndices(inputDeps);
 
             var childFromEntity = GetBufferFromEntity<Child>(true);
-            var verticesFromEntity = GetBufferFromEntity<ControlVertexData>(true);
-            var trianglesFromEntity = GetBufferFromEntity<ControlVertexIndex>(true);
+            var verticesFromEntity = GetBufferFromEntity<ElementVertexData>(true);
+            var trianglesFromEntity = GetBufferFromEntity<ElementVertexIndex>(true);
 
             using (new ProfilerSample("RenderSystem.BuildingChunks"))
             {
diff --git a/com.dotsui.core/DotsUI.Core/RectTransform.cs b/com.dotsui.core/DotsUI.Core/RectTransform.cs
index 187e4b1..dc98d36 100644
--- a/com.dotsui.core/DotsUI.Core/RectTransform.cs
+++ b/com.dotsui.core/DotsUI.Core/RectTransform.cs
@@ -4,6 +4,7 @@
 
 namespace DotsUI.Core
 {
+    [WriteGroup(typeof(Unity.Transforms.Child))]
     public struct RectTransform : IComponentData
     {
         public float2 AnchorMin;
diff --git a/com.dotsui.core/DotsUI.Core/RectTransformMissingComponentsSystem.cs b/com.dotsui.core/DotsUI.Core/RectTransformMissingComponentsSystem.cs
index 4ffdb45..d662752 100644
--- a/com.dotsui.core/DotsUI.Core/RectTransformMissingComponentsSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/RectTransformMissingComponentsSystem.cs
@@ -56,7 +56,7 @@ protected override void OnCreate()
                 None = new ComponentType[]
                 {
                     typeof(ElementCanvasReference),
-                    typeof(CanvasScreenSize)    // should be enough to exclude canvases
+                    typeof(CanvasSize)    // should be enough to exclude canvases
                 }
             });
             m_MissingHierarchyIndex = GetEntityQuery(new EntityQueryDesc()
diff --git a/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs b/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs
new file mode 100644
index 0000000..6511f76
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs
@@ -0,0 +1,382 @@
+using System;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Jobs;
+using Unity.Profiling;
+using Unity.Transforms;
+
+namespace DotsUI.Core
+{
+    [UpdateInGroup(typeof(TransformSystemGroup))]
+    [UpdateAfter(typeof(EndFrameParentSystem))]
+    [UnityEngine.ExecuteAlways]
+    public class EndFrameRectTransformParentSystem : RectTransformParentSystem
+    {
+    }
+    /// <summary>
+    /// This class is a copy of original unity parent system, with original components replaced for better performance.
+    /// Original unity parent system requires LocalToWorld and LocalToParent components.
+    /// These components add huge overhead, because of LocalToParentSystem execution.
+    /// Unity.Transforms.ParentSystem is overriden by WriteGroup over Child component.
+    /// </summary>
+    public abstract class RectTransformParentSystem : JobComponentSystem
+    {
+        EntityQuery m_NewParentsGroup;
+        //EntityQuery m_RemovedParentsGroup;
+        EntityQuery m_ExistingParentsGroup;
+        //EntityQuery m_DeletedParentsGroup;
+
+        static readonly ProfilerMarker k_ProfileDeletedParents = new ProfilerMarker("ParentSystem.DeletedParents");
+        static readonly ProfilerMarker k_ProfileRemoveParents = new ProfilerMarker("ParentSystem.RemoveParents");
+        static readonly ProfilerMarker k_ProfileChangeParents = new ProfilerMarker("ParentSystem.ChangeParents");
+        static readonly ProfilerMarker k_ProfileNewParents = new ProfilerMarker("ParentSystem.NewParents");
+
+        int FindChildIndex(DynamicBuffer<Child> children, Entity entity)
+        {
+            for (int i = 0; i < children.Length; i++)
+            {
+                if (children[i].Value == entity)
+                    return i;
+            }
+
+            throw new InvalidOperationException("Child entity not in parent");
+        }
+
+        //void RemoveChildFromParent(Entity childEntity, Entity parentEntity)
+        //{
+        //    if (!EntityManager.HasComponent<Child>(parentEntity))
+        //        return;
+
+        //    var children = EntityManager.GetBuffer<Child>(parentEntity);
+        //    var childIndex = FindChildIndex(children, childEntity);
+        //    children.RemoveAt(childIndex);
+        //    if (children.Length == 0)
+        //    {
+        //        EntityManager.RemoveComponent(parentEntity, typeof(Child));
+        //    }
+        //}
+
+        [BurstCompile]
+        struct GatherChangedParents : IJobChunk
+        {
+            public NativeMultiHashMap<Entity, Entity>.ParallelWriter ParentChildrenToAdd;
+            public NativeMultiHashMap<Entity, Entity>.ParallelWriter ParentChildrenToRemove;
+            public NativeHashMap<Entity, int>.ParallelWriter UniqueParents;
+            public ArchetypeChunkComponentType<PreviousParent> PreviousParentType;
+
+            [ReadOnly] public ArchetypeChunkComponentType<Parent> ParentType;
+            [ReadOnly] public ArchetypeChunkEntityType EntityType;
+            public uint LastSystemVersion;
+
+            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
+            {
+                if (chunk.DidChange(ParentType, LastSystemVersion))
+                {
+                    var chunkPreviousParents = chunk.GetNativeArray(PreviousParentType);
+                    var chunkParents = chunk.GetNativeArray(ParentType);
+                    var chunkEntities = chunk.GetNativeArray(EntityType);
+
+                    for (int j = 0; j < chunk.Count; j++)
+                    {
+                        if (chunkParents[j].Value != chunkPreviousParents[j].Value)
+                        {
+                            var childEntity = chunkEntities[j];
+                            var parentEntity = chunkParents[j].Value;
+                            var previousParentEntity = chunkPreviousParents[j].Value;
+
+                            ParentChildrenToAdd.Add(parentEntity, childEntity);
+                            UniqueParents.TryAdd(parentEntity, 0);
+
+                            if (previousParentEntity != Entity.Null)
+                            {
+                                ParentChildrenToRemove.Add(previousParentEntity, childEntity);
+                                UniqueParents.TryAdd(previousParentEntity, 0);
+                            }
+
+                            chunkPreviousParents[j] = new PreviousParent
+                            {
+                                Value = parentEntity
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        [BurstCompile]
+        struct FindMissingChild : IJob
+        {
+            [ReadOnly] public NativeHashMap<Entity, int> UniqueParents;
+            [ReadOnly] public BufferFromEntity<Child> ChildFromEntity;
+            public NativeList<Entity> ParentsMissingChild;
+
+            public void Execute()
+            {
+                var parents = UniqueParents.GetKeyArray(Allocator.Temp);
+                for (int i = 0; i < parents.Length; i++)
+                {
+                    var parent = parents[i];
+                    if (!ChildFromEntity.Exists(parent))
+                    {
+                        ParentsMissingChild.Add(parent);
+                    }
+                }
+            }
+        }
+
+        [BurstCompile]
+        struct FixupChangedChildren : IJob
+        {
+            [ReadOnly] public NativeMultiHashMap<Entity, Entity> ParentChildrenToAdd;
+            [ReadOnly] public NativeMultiHashMap<Entity, Entity> ParentChildrenToRemove;
+            [ReadOnly] public NativeHashMap<Entity, int> UniqueParents;
+
+            public BufferFromEntity<Child> ChildFromEntity;
+
+            int FindChildIndex(DynamicBuffer<Child> children, Entity entity)
+            {
+                for (int i = 0; i < children.Length; i++)
+                {
+                    if (children[i].Value == entity)
+                        return i;
+                }
+
+                throw new InvalidOperationException("Child entity not in parent");
+            }
+
+            void RemoveChildrenFromParent(Entity parent, DynamicBuffer<Child> children)
+            {
+                if (ParentChildrenToRemove.TryGetFirstValue(parent, out var child, out var it))
+                {
+                    do
+                    {
+                        var childIndex = FindChildIndex(children, child);
+                        children.RemoveAt(childIndex);
+
+                    } while (ParentChildrenToRemove.TryGetNextValue(out child, ref it));
+                }
+            }
+            void AddChildrenToParent(Entity parent, DynamicBuffer<Child> children)
+            {
+                if (ParentChildrenToAdd.TryGetFirstValue(parent, out var child, out var it))
+                {
+                    do
+                    {
+                        children.Add(new Child() { Value = child });
+                    } while (ParentChildrenToAdd.TryGetNextValue(out child, ref it));
+                }
+            }
+
+            public void Execute()
+            {
+                var parents = UniqueParents.GetKeyArray(Allocator.Temp);
+                for (int i = 0; i < parents.Length; i++)
+                {
+                    var parent = parents[i];
+                    var children = ChildFromEntity[parent];
+
+                    RemoveChildrenFromParent(parent, children);
+                    AddChildrenToParent(parent, children);
+                }
+            }
+        }
+
+        protected override void OnCreate()
+        {
+            m_NewParentsGroup = GetEntityQuery(new EntityQueryDesc
+            {
+                All = new ComponentType[]
+                {
+                    ComponentType.ReadOnly<Parent>(),
+                    ComponentType.ReadOnly<RectTransform>()
+                },
+                None = new ComponentType[]
+                {
+                    typeof(PreviousParent)
+                },
+                Options = EntityQueryOptions.FilterWriteGroup
+            });
+            //m_RemovedParentsGroup = GetEntityQuery(new EntityQueryDesc
+            //{
+            //    All = new ComponentType[]
+            //    {
+            //        typeof(PreviousParent)
+            //    },
+            //    None = new ComponentType[]
+            //    {
+            //        typeof(Parent)
+            //    },
+            //    Options = EntityQueryOptions.FilterWriteGroup
+            //});
+            m_ExistingParentsGroup = GetEntityQuery(new EntityQueryDesc
+            {
+                All = new ComponentType[]
+                {
+                    ComponentType.ReadOnly<Parent>(),
+                    ComponentType.ReadOnly<RectTransform>(),
+                    typeof(PreviousParent)
+                },
+                Options = EntityQueryOptions.FilterWriteGroup
+            });
+            m_ExistingParentsGroup.SetChangedVersionFilter(typeof(Parent));
+        }
+
+        void UpdateNewParents()
+        {
+            if (m_NewParentsGroup.IsEmptyIgnoreFilter)
+                return;
+
+            EntityManager.AddComponent(m_NewParentsGroup, typeof(PreviousParent));
+        }
+
+        //void UpdateRemoveParents()
+        //{
+        //    if (m_RemovedParentsGroup.IsEmptyIgnoreFilter)
+        //        return;
+
+        //    var childEntities = m_RemovedParentsGroup.ToEntityArray(Allocator.TempJob);
+        //    var previousParents = m_RemovedParentsGroup.ToComponentDataArray<PreviousParent>(Allocator.TempJob);
+
+        //    for (int i = 0; i < childEntities.Length; i++)
+        //    {
+        //        var childEntity = childEntities[i];
+        //        var previousParentEntity = previousParents[i].Value;
+
+        //        RemoveChildFromParent(childEntity, previousParentEntity);
+        //    }
+
+        //    EntityManager.RemoveComponent(m_RemovedParentsGroup, typeof(PreviousParent));
+        //    childEntities.Dispose();
+        //    previousParents.Dispose();
+        //}
+
+        void UpdateChangeParents()
+        {
+            if (m_ExistingParentsGroup.IsEmptyIgnoreFilter)
+                return;
+
+            var count = m_ExistingParentsGroup.CalculateEntityCount();
+            if (count == 0)
+                return;
+
+            // 1. Get (Parent,Child) to remove
+            // 2. Get (Parent,Child) to add
+            // 3. Get unique Parent change list
+            // 4. Set PreviousParent to new Parent
+            var parentChildrenToAdd = new NativeMultiHashMap<Entity, Entity>(count, Allocator.TempJob);
+            var parentChildrenToRemove = new NativeMultiHashMap<Entity, Entity>(count, Allocator.TempJob);
+            var uniqueParents = new NativeHashMap<Entity, int>(count, Allocator.TempJob);
+            var gatherChangedParentsJob = new GatherChangedParents
+            {
+                ParentChildrenToAdd = parentChildrenToAdd.AsParallelWriter(),
+                ParentChildrenToRemove = parentChildrenToRemove.AsParallelWriter(),
+                UniqueParents = uniqueParents.AsParallelWriter(),
+                PreviousParentType = GetArchetypeChunkComponentType<PreviousParent>(false),
+                ParentType = GetArchetypeChunkComponentType<Parent>(true),
+                EntityType = GetArchetypeChunkEntityType(),
+                LastSystemVersion = LastSystemVersion
+            };
+            var gatherChangedParentsJobHandle = gatherChangedParentsJob.Schedule(m_ExistingParentsGroup);
+            gatherChangedParentsJobHandle.Complete();
+
+            // 5. (Structural change) Add any missing Child to Parents
+            var parentsMissingChild = new NativeList<Entity>(Allocator.TempJob);
+            var findMissingChildJob = new FindMissingChild
+            {
+                UniqueParents = uniqueParents,
+                ChildFromEntity = GetBufferFromEntity<Child>(),
+                ParentsMissingChild = parentsMissingChild
+            };
+            var findMissingChildJobHandle = findMissingChildJob.Schedule();
+            findMissingChildJobHandle.Complete();
+
+            EntityManager.AddComponent(parentsMissingChild.AsArray(), typeof(Child));
+
+            // 6. Get Child[] for each unique Parent
+            // 7. Update Child[] for each unique Parent
+            var fixupChangedChildrenJob = new FixupChangedChildren
+            {
+                ParentChildrenToAdd = parentChildrenToAdd,
+                ParentChildrenToRemove = parentChildrenToRemove,
+                UniqueParents = uniqueParents,
+                ChildFromEntity = GetBufferFromEntity<Child>()
+            };
+
+            var fixupChangedChildrenJobHandle = fixupChangedChildrenJob.Schedule();
+            fixupChangedChildrenJobHandle.Complete();
+
+            parentChildrenToAdd.Dispose();
+            parentChildrenToRemove.Dispose();
+            uniqueParents.Dispose();
+            parentsMissingChild.Dispose();
+        }
+
+        [BurstCompile]
+        struct GatherChildEntities : IJob
+        {
+            public NativeArray<Entity> Parents;
+            public NativeList<Entity> Children;
+            public BufferFromEntity<Child> ChildFromEntity;
+
+            public void Execute()
+            {
+                for (int i = 0; i < Parents.Length; i++)
+                {
+                    var parentEntity = Parents[i];
+                    var childEntitiesSource = ChildFromEntity[parentEntity].AsNativeArray();
+                    for (int j = 0; j < childEntitiesSource.Length; j++)
+                        Children.Add(childEntitiesSource[j].Value);
+                }
+            }
+        }
+
+        //void UpdateDeletedParents()
+        //{
+        //    if (m_DeletedParentsGroup.IsEmptyIgnoreFilter)
+        //        return;
+
+        //    var previousParents = m_DeletedParentsGroup.ToEntityArray(Allocator.TempJob);
+        //    var childEntities = new NativeList<Entity>(Allocator.TempJob);
+        //    var gatherChildEntitiesJob = new GatherChildEntities
+        //    {
+        //        Parents = previousParents,
+        //        Children = childEntities,
+        //        ChildFromEntity = GetBufferFromEntity<Child>()
+        //    };
+        //    var gatherChildEntitiesJobHandle = gatherChildEntitiesJob.Schedule();
+        //    gatherChildEntitiesJobHandle.Complete();
+
+        //    EntityManager.RemoveComponent(childEntities, typeof(Parent));
+        //    EntityManager.RemoveComponent(childEntities, typeof(PreviousParent));
+        //    EntityManager.RemoveComponent(childEntities, typeof(LocalToParent));
+        //    EntityManager.RemoveComponent(m_DeletedParentsGroup, typeof(Child));
+
+        //    childEntities.Dispose();
+        //    previousParents.Dispose();
+        //}
+
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
+        {
+            inputDeps.Complete(); // #todo
+
+            //k_ProfileDeletedParents.Begin();
+            //UpdateDeletedParents();
+            //k_ProfileDeletedParents.End();
+
+            //k_ProfileRemoveParents.Begin();
+            //UpdateRemoveParents();
+            //k_ProfileRemoveParents.End();
+
+            k_ProfileNewParents.Begin();
+            UpdateNewParents();
+            k_ProfileNewParents.End();
+
+            k_ProfileChangeParents.Begin();
+            UpdateChangeParents();
+            k_ProfileChangeParents.End();
+
+            return new JobHandle();
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs.meta b/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs.meta
new file mode 100644
index 0000000..f2ed284
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/RectTransformParentSystem.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 570b7bfce627c2f4a81c45704ae8c630
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Core/RectTransformSystem.cs b/com.dotsui.core/DotsUI.Core/RectTransformSystem.cs
index fce62af..97eead5 100644
--- a/com.dotsui.core/DotsUI.Core/RectTransformSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/RectTransformSystem.cs
@@ -19,7 +19,7 @@ private struct UpdateHierarchy : IJobChunk
             [ReadOnly]
             public float2 Dpi;
             [ReadOnly] public ArchetypeChunkComponentType<RectTransform> RectTransformType;
-            [ReadOnly] public ArchetypeChunkComponentType<CanvasScreenSize> CanvasSizeType;
+            [ReadOnly] public ArchetypeChunkComponentType<CanvasSize> CanvasSizeType;
             [ReadOnly] public ArchetypeChunkEntityType EntityType;
             [ReadOnly] public ArchetypeChunkBufferType<Child> ChildType;
             [ReadOnly] public ArchetypeChunkComponentType<CanvasConstantPhysicalSizeScaler> ConstantPhysicalScaler;
@@ -74,7 +74,7 @@ protected override void OnCreate()
                 All = new ComponentType[]
                 {
                     ComponentType.ReadOnly<RectTransform>(),
-                    ComponentType.ReadOnly<CanvasScreenSize>(),
+                    ComponentType.ReadOnly<CanvasSize>(),
                     ComponentType.ReadOnly<Child>(),
                     ComponentType.ReadOnly<RebuildCanvasHierarchyFlag>(),
                     typeof(WorldSpaceRect),
@@ -100,7 +100,7 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
             {
                 Dpi = new float2(dpi, dpi),
                 RectTransformType = GetArchetypeChunkComponentType<RectTransform>(true),
-                CanvasSizeType = GetArchetypeChunkComponentType<CanvasScreenSize>(true),
+                CanvasSizeType = GetArchetypeChunkComponentType<CanvasSize>(true),
                 EntityType = entityType,
                 ChildType = childType,
                 ConstantPhysicalScaler = GetArchetypeChunkComponentType<CanvasConstantPhysicalSizeScaler>(true),
diff --git a/com.dotsui.core/DotsUI.Core/SpriteMeshBuildSystem.cs b/com.dotsui.core/DotsUI.Core/SpriteMeshBuildSystem.cs
index 319e631..b7314ff 100644
--- a/com.dotsui.core/DotsUI.Core/SpriteMeshBuildSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/SpriteMeshBuildSystem.cs
@@ -18,12 +18,13 @@ protected override void OnCreate()
                 All = new ComponentType[]
                 {
                     ComponentType.ReadOnly<SpriteImage>(),
-                    ComponentType.ReadWrite<ControlVertexData>(),
-                    ComponentType.ReadWrite<ControlVertexIndex>(),
-                    ComponentType.ReadOnly<RebuildElementMeshFlag>(), 
+                    ComponentType.ReadWrite<ElementVertexData>(),
+                    ComponentType.ReadWrite<ElementVertexIndex>(),
+                    ComponentType.ReadOnly<RebuildElementMeshFlag>(),
+                    ComponentType.ReadOnly<WorldSpaceRect>(),
                 }
             });
-            m_SpriteGroup.SetFilterChanged(typeof(RebuildElementMeshFlag));
+            m_SpriteGroup.SetChangedVersionFilter(typeof(WorldSpaceRect));
         }
 
         [BurstCompile]
@@ -31,8 +32,8 @@ struct SpriteBatchJob : IJobChunk
         {
             //[ReadOnly] public NativeHashMap<int, SpriteVertexData> SpriteData;
             [ReadOnly] public ComponentDataFromEntity<SpriteVertexData> SpriteDataFromEntity;
-            public ArchetypeChunkBufferType<ControlVertexData> VertexDataType;
-            public ArchetypeChunkBufferType<ControlVertexIndex> VertexIndexType;
+            public ArchetypeChunkBufferType<ElementVertexData> VertexDataType;
+            public ArchetypeChunkBufferType<ElementVertexIndex> VertexIndexType;
             [ReadOnly] public ArchetypeChunkComponentType<SpriteImage> SpriteImageType;
             [ReadOnly] public ArchetypeChunkComponentType<WorldSpaceRect> WorldSpaceRectType;
             [ReadOnly] public ArchetypeChunkComponentType<WorldSpaceMask> WorldSpaceMaskType;
@@ -48,10 +49,10 @@ public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
                 NativeArray<VertexColorValue> colorValues = chunk.GetNativeArray(ColorValueType);
                 NativeArray<VertexColorMultiplier> colorMultipliers = chunk.GetNativeArray(ColorMultiplierType);
                 NativeArray<RebuildElementMeshFlag> rebuildFlagArray = chunk.GetNativeArray(RebuildElementMeshFlagType);
-                BufferAccessor<ControlVertexData> vertexDataAccessor = chunk.GetBufferAccessor(VertexDataType);
-                BufferAccessor<ControlVertexIndex> vertexIndexAccessor = chunk.GetBufferAccessor(VertexIndexType);
+                BufferAccessor<ElementVertexData> vertexDataAccessor = chunk.GetBufferAccessor(VertexDataType);
+                BufferAccessor<ElementVertexIndex> vertexIndexAccessor = chunk.GetBufferAccessor(VertexIndexType);
 
-                for(int i = 0; i < chunk.Count; i++)
+                for (int i = 0; i < chunk.Count; i++)
                 {
                     if (rebuildFlagArray[i].Rebuild)
                     {
@@ -68,28 +69,30 @@ public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
                         {
                             var spriteData = SpriteDataFromEntity[assetEntity];
                             // TODO: Simple sprite (non sliced)
-                            SpriteUtility.PopulateSpriteVertices(ref worldSpaceMask, ref vertices, ref triangles, ref worldSpaceRect, ref spriteData, colorValues[i].Value*colorMultipliers[i].Value);
+                            SpriteUtility.PopulateSpriteVertices(ref worldSpaceMask, ref vertices, ref triangles, ref worldSpaceRect, ref spriteData, colorValues[i].Value * colorMultipliers[i].Value);
                         }
                         else
                         {
                             var spriteData = SpriteVertexData.Default;
                             SpriteUtility.PopulateSpriteVertices(ref worldSpaceMask, ref vertices, ref triangles, ref worldSpaceRect, ref spriteData, colorValues[i].Value * colorMultipliers[i].Value);
                         }
-                        rebuildFlagArray[i] = new RebuildElementMeshFlag(){Rebuild = false};
+                        rebuildFlagArray[i] = new RebuildElementMeshFlag() { Rebuild = false };
                     }
                 }
             }
         }
         protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
+            if (m_SpriteGroup.CalculateEntityCount() < 0)
+                return inputDeps;
             SpriteBatchJob batchJob = new SpriteBatchJob()
             {
                 ColorValueType = GetArchetypeChunkComponentType<VertexColorValue>(true),
                 ColorMultiplierType = GetArchetypeChunkComponentType<VertexColorMultiplier>(true),
                 SpriteDataFromEntity = GetComponentDataFromEntity<SpriteVertexData>(),
                 SpriteImageType = GetArchetypeChunkComponentType<SpriteImage>(true),
-                VertexDataType = GetArchetypeChunkBufferType<ControlVertexData>(),
-                VertexIndexType = GetArchetypeChunkBufferType<ControlVertexIndex>(),
+                VertexDataType = GetArchetypeChunkBufferType<ElementVertexData>(),
+                VertexIndexType = GetArchetypeChunkBufferType<ElementVertexIndex>(),
                 WorldSpaceRectType = GetArchetypeChunkComponentType<WorldSpaceRect>(true),
                 WorldSpaceMaskType = GetArchetypeChunkComponentType<WorldSpaceMask>(true),
                 RebuildElementMeshFlagType = GetArchetypeChunkComponentType<RebuildElementMeshFlag>()
diff --git a/com.dotsui.core/DotsUI.Core/SpriteUtility.cs b/com.dotsui.core/DotsUI.Core/SpriteUtility.cs
index a8d4973..b3c88ac 100644
--- a/com.dotsui.core/DotsUI.Core/SpriteUtility.cs
+++ b/com.dotsui.core/DotsUI.Core/SpriteUtility.cs
@@ -51,8 +51,8 @@ public static SpriteVertexData GetSpriteVertexData(Sprite sprite)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe void PopulateSpriteVertices(ref WorldSpaceMask rectMask, ref DynamicBuffer<ControlVertexData> vertices,
-            ref DynamicBuffer<ControlVertexIndex> triangles, ref WorldSpaceRect rectData,
+        public static unsafe void PopulateSpriteVertices(ref WorldSpaceMask rectMask, ref DynamicBuffer<ElementVertexData> vertices,
+            ref DynamicBuffer<ElementVertexIndex> triangles, ref WorldSpaceRect rectData,
             ref SpriteVertexData spriteVertexData, float4 color)
         {
             float pixelsPerUnit = spriteVertexData.PixelsPerUnit / 100.0f;
@@ -97,7 +97,7 @@ public static unsafe void PopulateSpriteVertices(ref WorldSpaceMask rectMask, re
             {
                 for (int y = 0; y < 4; ++y)
                 {
-                    vertices.Add(new ControlVertexData()
+                    vertices.Add(new ElementVertexData()
                     {
                         Position = new float3(vertScratch[x].x, vertScratch[y].y, 0.0f),
                         TexCoord0 = new float2(uvScratch[x].x, uvScratch[y].y),
diff --git a/com.dotsui.core/DotsUI.Core/TextFontAsset.cs b/com.dotsui.core/DotsUI.Core/TextFontAsset.cs
index f109435..9ebcb5e 100644
--- a/com.dotsui.core/DotsUI.Core/TextFontAsset.cs
+++ b/com.dotsui.core/DotsUI.Core/TextFontAsset.cs
@@ -5,6 +5,8 @@
 using UnityEngine;
 using UnityEngine.TextCore;
 
+//using UnityEngine.TextCore;
+
 namespace DotsUI.Core
 {
     public struct TextFontAsset : IComponentData
diff --git a/com.dotsui.core/DotsUI.Core/TextMeshBuildSystem.cs b/com.dotsui.core/DotsUI.Core/TextMeshBuildSystem.cs
index c93efc7..b85725e 100644
--- a/com.dotsui.core/DotsUI.Core/TextMeshBuildSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/TextMeshBuildSystem.cs
@@ -9,27 +9,6 @@
 
 namespace DotsUI.Core
 {
-    public struct GlyphInfo
-    {
-        public float Scale;
-        public GlyphRect Rect;
-        public GlyphMetrics Metrics;
-    }
-
-    public struct FontInfo
-    {
-        public float LineHeight;
-        public float NormalSpace;
-        public float BoldSpace;
-        public float AscentLine;
-        public float CapLine;
-        public float MeanLine;
-        public float Baseline;
-        public float DescentLine;
-        public float PointSize;
-        public float BoldStyle;
-        public float NormalStyle;
-    }
 
     [UnityEngine.ExecuteAlways]
     [UpdateInGroup(typeof(ElementMeshUpdateSystemGroup))]
@@ -38,7 +17,6 @@ public class TextMeshBuildSystem : JobComponentSystem
         [BurstCompile(FloatMode = FloatMode.Fast)]
         private struct TextChunkBuilder : IJobChunk
         {
-            [ReadOnly] public ArchetypeChunkEntityType TextEntities;
             [ReadOnly] public ArchetypeChunkComponentType<WorldSpaceRect> WorldSpaceRectType;
             [ReadOnly] public ArchetypeChunkComponentType<VertexColorValue> ColorValueType;
             [ReadOnly] public ArchetypeChunkComponentType<VertexColorMultiplier> ColorMultiplierType;
@@ -51,9 +29,9 @@ private struct TextChunkBuilder : IJobChunk
             [ReadOnly] public BufferFromEntity<FontGlyphData> FontGlyphDataFromEntity;
 
             [NativeDisableContainerSafetyRestriction]
-            public ArchetypeChunkBufferType<ControlVertexData> VertexDataType;
+            public ArchetypeChunkBufferType<ElementVertexData> VertexDataType;
             [NativeDisableContainerSafetyRestriction]
-            public ArchetypeChunkBufferType<ControlVertexIndex> IndexDataType;
+            public ArchetypeChunkBufferType<ElementVertexIndex> IndexDataType;
 
             [ReadOnly]
             public ArchetypeChunkBufferType<TextData> TextBufferType;
@@ -95,7 +73,7 @@ public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
             }
 
 
-            private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMask mask, TextRenderer settings, float4 color, ref DynamicBuffer<TextData> textBuffer, ref DynamicBuffer<ControlVertexData> vertices, ref DynamicBuffer<ControlVertexIndex> triangles)
+            private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMask mask, TextRenderer settings, float4 color, ref DynamicBuffer<TextData> textBuffer, ref DynamicBuffer<ElementVertexData> vertices, ref DynamicBuffer<ElementVertexIndex> triangles)
             {
                 _VerticalAlignmentOptions verticalAlignment = (_VerticalAlignmentOptions)settings.Alignment;
                 _HorizontalAlignmentOptions horizontalAlignment = (_HorizontalAlignmentOptions)settings.Alignment;
@@ -151,15 +129,15 @@ private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMas
                             uv.xy = uv.xy + cut.UvMin;
                             uv.zw = uv.zw - cut.UvMax;
 
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex + 2 });
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex + 1 });
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex + 2 });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex + 1 });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex });
 
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex + 3 });
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex + 2 });
-                            triangles.Add(new ControlVertexIndex() { Value = startIndex });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex + 3 });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex + 2 });
+                            triangles.Add(new ElementVertexIndex() { Value = startIndex });
 
-                            vertices.Add(new ControlVertexData()
+                            vertices.Add(new ElementVertexData()
                             {
                                 Position = new float3(vertexPos.xy, 0.0f),
                                 Normal = new float3(0.0f, 0.0f, -1.0f),
@@ -167,7 +145,7 @@ private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMas
                                 TexCoord1 = uv2,
                                 Color = color
                             });
-                            vertices.Add(new ControlVertexData()
+                            vertices.Add(new ElementVertexData()
                             {
                                 Position = new float3(vertexPos.zy, 0.0f),
                                 Normal = new float3(0.0f, 0.0f, -1.0f),
@@ -175,7 +153,7 @@ private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMas
                                 TexCoord1 = uv2,
                                 Color = color
                             });
-                            vertices.Add(new ControlVertexData()
+                            vertices.Add(new ElementVertexData()
                             {
                                 Position = new float3(vertexPos.zw, 0.0f),
                                 Normal = new float3(0.0f, 0.0f, -1.0f),
@@ -183,7 +161,7 @@ private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMas
                                 TexCoord1 = uv2,
                                 Color = color
                             });
-                            vertices.Add(new ControlVertexData()
+                            vertices.Add(new ElementVertexData()
                             {
                                 Position = new float3(vertexPos.xw, 0.0f),
                                 Normal = new float3(0.0f, 0.0f, -1.0f),
@@ -214,55 +192,39 @@ protected override void OnCreate()
                 All = new ComponentType[]
                 {
                     ComponentType.ReadOnly<WorldSpaceRect>(),
-                    ComponentType.ReadWrite<ControlVertexData>(),
-                    ComponentType.ReadWrite<ControlVertexIndex>(),
+                    ComponentType.ReadWrite<ElementVertexData>(),
+                    ComponentType.ReadWrite<ElementVertexIndex>(),
                     ComponentType.ReadOnly<TextRenderer>(),
                     ComponentType.ReadOnly<TextData>(),
                     ComponentType.ReadOnly<RebuildElementMeshFlag>(),
                 },
                 Options = EntityQueryOptions.FilterWriteGroup
             });
+            m_TextGroup.SetChangedVersionFilter(ComponentType.ReadOnly(typeof(WorldSpaceRect)));
         }
 
         protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
+            if (m_TextGroup.CalculateEntityCount() <= 0)
+                return inputDeps;
             TextChunkBuilder chunkJob = new TextChunkBuilder()
             {
-                TextEntities = GetArchetypeChunkEntityType(),
                 TextBufferType = GetArchetypeChunkBufferType<TextData>(true),
                 WorldSpaceRectType = GetArchetypeChunkComponentType<WorldSpaceRect>(true),
                 ColorValueType = GetArchetypeChunkComponentType<VertexColorValue>(true),
                 ColorMultiplierType = GetArchetypeChunkComponentType<VertexColorMultiplier>(true),
                 TextRendererType = GetArchetypeChunkComponentType<TextRenderer>(true),
-                VertexDataType = GetArchetypeChunkBufferType<ControlVertexData>(),
-                IndexDataType = GetArchetypeChunkBufferType<ControlVertexIndex>(),
+                VertexDataType = GetArchetypeChunkBufferType<ElementVertexData>(),
+                IndexDataType = GetArchetypeChunkBufferType<ElementVertexIndex>(),
                 RebuildElementMeshFlagArray = GetArchetypeChunkComponentType<RebuildElementMeshFlag>(),
                 FontAssetFromEntity = GetComponentDataFromEntity<TextFontAsset>(true),
                 FontGlyphDataFromEntity = GetBufferFromEntity<FontGlyphData>(true),
                 ElementScaleType = GetArchetypeChunkComponentType<ElementScale>(true),
                 WorldSpaceMaskType = GetArchetypeChunkComponentType<WorldSpaceMask>(true)
             };
-            //inputDeps = chunkJob.Schedule(chunkJob.TextEntities.Length, 1, inputDeps);
             inputDeps = chunkJob.Schedule(m_TextGroup, inputDeps);
-            //}
 
             return inputDeps;
         }
-
-        private NativeHashMap<ushort, GlyphInfo> CreateGlyphDataLookupTable(TMP_FontAsset font, Allocator allocator)
-        {
-            NativeHashMap<ushort, GlyphInfo> ret = new NativeHashMap<ushort, GlyphInfo>(font.glyphLookupTable.Count, allocator);
-            foreach (var glyph in font.characterLookupTable)
-            {
-                ret.TryAdd((ushort)glyph.Key, new GlyphInfo()
-                {
-                    Scale = glyph.Value.scale,
-                    Rect = glyph.Value.glyph.glyphRect,
-                    Metrics = glyph.Value.glyph.metrics
-                });
-            }
-
-            return ret;
-        }
     }
 }
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Core/TextUtils.cs b/com.dotsui.core/DotsUI.Core/TextUtils.cs
index f3cf9f4..6ccf7dd 100644
--- a/com.dotsui.core/DotsUI.Core/TextUtils.cs
+++ b/com.dotsui.core/DotsUI.Core/TextUtils.cs
@@ -13,16 +13,7 @@ public struct TextLineInfo
             public float LineWidth;
         }
 
-        public static Entity CreateFontAssetFromTmp(EntityManager mgr, TMP_FontAsset font)
-        {
-	        var entity = mgr.CreateEntity(typeof(TextFontAsset), typeof(LegacyTextFontAsset), typeof(FontGlyphData));
-
-			SetupFontAssetFromTmp(mgr, entity, font);
-
-			return entity;
-        }
-
-		public static void SetupFontAssetFromTmp(EntityManager mgr, Entity entity, TMP_FontAsset font)
+        public static void SetupFontAssetFromTmp(EntityManager mgr, Entity entity, TMP_FontAsset font)
 		{ 
 			mgr.SetSharedComponentData(entity, new LegacyTextFontAsset
             {
diff --git a/com.dotsui.core/DotsUI.Core/UpdateElementColorSystem.cs b/com.dotsui.core/DotsUI.Core/UpdateElementColorSystem.cs
index 0a8db63..8505243 100644
--- a/com.dotsui.core/DotsUI.Core/UpdateElementColorSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/UpdateElementColorSystem.cs
@@ -20,7 +20,7 @@ protected override void OnCreate()
                     ComponentType.ReadOnly<UpdateElementColor>(),
                     ComponentType.ReadOnly<VertexColorValue>(),
                     ComponentType.ReadOnly<VertexColorMultiplier>(),
-                    ComponentType.ReadWrite<ControlVertexData>(),
+                    ComponentType.ReadWrite<ElementVertexData>(),
                     ComponentType.ReadOnly<RebuildElementMeshFlag>(), 
                 }
             });
@@ -31,7 +31,7 @@ struct UpdateColorVertices : IJobChunk
         {
             [NativeDisableContainerSafetyRestriction] public BufferFromEntity<MeshVertex> VertexFromCanvasEntity;
             [ReadOnly] public ComponentDataFromEntity<Parent> ParentFromEntity;
-            [NativeDisableContainerSafetyRestriction]public ArchetypeChunkBufferType<ControlVertexData> VertexDataType;
+            [NativeDisableContainerSafetyRestriction]public ArchetypeChunkBufferType<ElementVertexData> VertexDataType;
             [ReadOnly] public ArchetypeChunkComponentType<ElementVertexPointerInMesh> VertexPointerInCanvasMeshType;
             [ReadOnly] public ArchetypeChunkEntityType EntityType;
             [ReadOnly] public ArchetypeChunkComponentType<VertexColorValue> VertexColorType;
@@ -87,7 +87,7 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                 ParentFromEntity = GetComponentDataFromEntity<Parent>(true),
                 VertexColorType = GetArchetypeChunkComponentType<VertexColorValue>(true),
                 VertexColorMultiplierType = GetArchetypeChunkComponentType<VertexColorMultiplier>(true),
-                VertexDataType = GetArchetypeChunkBufferType<ControlVertexData>(),
+                VertexDataType = GetArchetypeChunkBufferType<ElementVertexData>(),
                 VertexFromCanvasEntity = GetBufferFromEntity<MeshVertex>(),
                 VertexPointerInCanvasMeshType = GetArchetypeChunkComponentType<ElementVertexPointerInMesh>(true),
                 RebuildElementMeshFlagType = GetArchetypeChunkComponentType<RebuildElementMeshFlag>(true)
diff --git a/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs b/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs
new file mode 100644
index 0000000..c711f2b
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DotsUI.Profiling;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Entities;
+using Unity.Jobs;
+
+namespace DotsUI.Core.Utils
+{
+    public struct AddComponentDataCommandBuffer<T> : IDisposable where T : struct, IComponentData
+    {
+        [ReadOnly]
+        private NativeQueue<(Entity, T)> m_EntityList;
+
+        public AddComponentDataCommandBuffer(Allocator allocator)
+        {
+            m_EntityList = new NativeQueue<(Entity, T)>(allocator);
+        }
+
+        public ParallelWriter AsParallelWriter()
+        {
+            return new ParallelWriter(m_EntityList.AsParallelWriter());
+        }
+
+        public bool IsCreated => m_EntityList.IsCreated;
+
+        public void Playback(EntityManager manager)
+        {
+            using (new ProfilerSample("AddFlagCommandBuffer.Playback"))
+            {
+                while (m_EntityList.TryDequeue(out var entityData))
+                {
+                    manager.AddComponentData(entityData.Item1, entityData.Item2);
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            m_EntityList.Dispose();
+        }
+
+        public JobHandle Dispose(JobHandle inputDeps)
+        {
+            return m_EntityList.Dispose(inputDeps);
+        }
+
+        public struct ParallelWriter
+        {
+            private NativeQueue<(Entity, T)>.ParallelWriter m_Writer;
+
+            public ParallelWriter(NativeQueue<(Entity, T)>.ParallelWriter writer)
+            {
+                m_Writer = writer;
+            }
+
+            public void TryAdd(Entity entity, T data)
+            {
+                m_Writer.Enqueue((entity, data));
+            }
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs.meta b/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs.meta
new file mode 100644
index 0000000..4abcb85
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/Utils/AddComponentDataCommandBuffer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c208584b0226c242b33188f9cbb6e24
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Core/Utils/AddFlagComponentCommandBuffer.cs b/com.dotsui.core/DotsUI.Core/Utils/AddFlagComponentCommandBuffer.cs
index 9bca54e..e1c5203 100644
--- a/com.dotsui.core/DotsUI.Core/Utils/AddFlagComponentCommandBuffer.cs
+++ b/com.dotsui.core/DotsUI.Core/Utils/AddFlagComponentCommandBuffer.cs
@@ -6,58 +6,77 @@
 
 namespace DotsUI.Core.Utils
 {
-    public struct AddFlagComponentCommandBuffer : IDisposable
+    public struct FlagComponentCommandBuffer : IDisposable
     {
-        [ReadOnly]
-        private NativeQueue<Entity> m_EntityList;
+        private NativeQueue<Entity> m_AddList;
+        private NativeQueue<Entity> m_RemoveList;
         private ComponentType m_ComponentType;
 
-
-        public AddFlagComponentCommandBuffer(ComponentType componentType, Allocator allocator)
+        public FlagComponentCommandBuffer(ComponentType componentType, Allocator allocator)
         {
-            m_EntityList = new NativeQueue<Entity>(allocator);
+            m_AddList = new NativeQueue<Entity>(allocator);
+            m_RemoveList = new NativeQueue<Entity>(allocator);
             m_ComponentType = componentType;
         }
 
         public ParallelWriter AsParallelWriter()
         {
-            return new ParallelWriter(m_EntityList.AsParallelWriter());
+            return new ParallelWriter(m_AddList.AsParallelWriter(), m_RemoveList.AsParallelWriter());
         }
 
         public void Playback(EntityManager manager)
         {
             using (new ProfilerSample("AddFlagCommandBuffer.Playback"))
             {
-                var asArray = new NativeArray<Entity>(m_EntityList.Count, Allocator.TempJob);
-                for (int i = 0; i < asArray.Length; i++)
-                    asArray[i] = m_EntityList.Dequeue();
-                manager.AddComponent(asArray, m_ComponentType);
-                asArray.Dispose();
+                if(m_AddList.Count > 0)
+                {
+                    var asArray = new NativeArray<Entity>(m_AddList.Count, Allocator.TempJob);
+                    for (int i = 0; i < asArray.Length; i++)
+                        asArray[i] = m_AddList.Dequeue();
+                    manager.AddComponent(asArray, m_ComponentType);
+                    asArray.Dispose();
+                }
+
+                if(m_RemoveList.Count > 0)
+                {
+                    var asArray = new NativeArray<Entity>(m_RemoveList.Count, Allocator.TempJob);
+                    for (int i = 0; i < asArray.Length; i++)
+                        asArray[i] = m_RemoveList.Dequeue();
+                    manager.RemoveComponent(asArray, m_ComponentType);
+                    asArray.Dispose();
+                }
             }
         }
 
         public void Dispose()
         {
-            m_EntityList.Dispose();
+            m_AddList.Dispose();
+            m_RemoveList.Dispose();
         }
 
         public JobHandle Dispose(JobHandle inputDeps)
         {
-            return m_EntityList.Dispose(inputDeps);
+            return m_AddList.Dispose(inputDeps);
         }
 
         public struct ParallelWriter
         {
-            private NativeQueue<Entity>.ParallelWriter m_Writer;
+            private NativeQueue<Entity>.ParallelWriter m_AddWriter;
+            private NativeQueue<Entity>.ParallelWriter m_RemoveWriter;
 
-            public ParallelWriter(NativeQueue<Entity>.ParallelWriter writer)
+            internal ParallelWriter(NativeQueue<Entity>.ParallelWriter addWriter, NativeQueue<Entity>.ParallelWriter removeWriter)
             {
-                m_Writer = writer;
+                m_AddWriter = addWriter;
+                m_RemoveWriter = removeWriter;
             }
 
             public void TryAdd(Entity entity)
             {
-                m_Writer.Enqueue(entity);
+                m_AddWriter.Enqueue(entity);
+            }
+            public void TryRemove(Entity entity)
+            {
+                m_RemoveWriter.Enqueue(entity);
             }
         }
     }
diff --git a/com.dotsui.core/DotsUI.Core/Utils/MicroCommandBufferSystem.cs b/com.dotsui.core/DotsUI.Core/Utils/MicroCommandBufferSystem.cs
index 8b28c8f..19dad33 100644
--- a/com.dotsui.core/DotsUI.Core/Utils/MicroCommandBufferSystem.cs
+++ b/com.dotsui.core/DotsUI.Core/Utils/MicroCommandBufferSystem.cs
@@ -6,17 +6,18 @@ namespace DotsUI.Core.Utils
 {
     public class MicroCommandBufferSystem : EntityCommandBufferSystem
     {
-        private List<AddFlagComponentCommandBuffer> m_AddFlagBuffers = new List<AddFlagComponentCommandBuffer>(32);
-        public AddFlagComponentCommandBuffer CreateAddFlagComponentCommandBuffer<T>() where T : IComponentData
+        private List<FlagComponentCommandBuffer> m_AddFlagBuffers = new List<FlagComponentCommandBuffer>(32);
+        
+        public FlagComponentCommandBuffer CreateFlagComponentCommandBuffer<T>() where T : IComponentData
         {
-            var flagBuffer = new AddFlagComponentCommandBuffer(typeof(T), Allocator.TempJob);
+            var flagBuffer = new FlagComponentCommandBuffer(typeof(T), Allocator.TempJob);
             m_AddFlagBuffers.Add(flagBuffer);
             return flagBuffer;
         }
         protected override void OnCreate()
         {
             base.OnCreate();
-            //m_AddFlagBuffers = new NativeList<AddFlagComponentCommandBuffer>(Allocator.Persistent);
+            //m_AddFlagBuffers = new NativeList<FlagComponentCommandBuffer>(Allocator.Persistent);
         }
 
         protected override void OnDestroy()
diff --git a/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs b/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs
new file mode 100644
index 0000000..f8d41f5
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace DotsUI.Core.Utils
+{
+    internal unsafe struct NativeCollectionBucket
+    {
+        public int Count;
+        public int Capacity;
+        public void* BuffPtr;
+    }
+    internal unsafe struct NativeCollectionHeader
+    {
+        public int BucketCount;
+        public int BucketCapacity;
+
+        public NativeCollectionBucket* BucketPtr;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    [NativeContainer]
+    public unsafe struct NativeUnorderedCollection<T> : IDisposable where T : struct
+    {
+        [NativeDisableUnsafePtrRestriction] private NativeCollectionHeader* m_Header;
+
+        Allocator m_AllocatorLabel;
+        public NativeUnorderedCollection(int capacity, Allocator allocator)
+        {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            if (!UnsafeUtility.IsBlittable<T>())
+                throw new ArgumentException(string.Format("{0} used in NativeQueue<{0}> must be blittable", typeof(T)));
+#endif
+            m_AllocatorLabel = allocator;
+            m_Header = (NativeCollectionHeader*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<NativeCollectionHeader>(), 4, allocator);
+        }
+
+        public void Dispose()
+        {
+            UnsafeUtility.Free(m_Header, m_AllocatorLabel);
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs.meta b/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs.meta
new file mode 100644
index 0000000..37141be
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Core/Utils/NativeUniqueCollection.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b5859bcb72b9094fa5e9ae5627ea50d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Editor/DotsUI.Editor.asmdef b/com.dotsui.core/DotsUI.Editor/DotsUI.Editor.asmdef
index 20d3c0d..ea64cf1 100644
--- a/com.dotsui.core/DotsUI.Editor/DotsUI.Editor.asmdef
+++ b/com.dotsui.core/DotsUI.Editor/DotsUI.Editor.asmdef
@@ -4,7 +4,8 @@
         "GUID:d7eb76657380f0942b1816e18f4aa72a",
         "GUID:10ff06164b46ab543955b32318731559",
         "GUID:734d92eba21c94caba915361bd5ac177",
-        "GUID:a5baed0c9693541a5bd947d336ec7659"
+        "GUID:a5baed0c9693541a5bd947d336ec7659",
+        "GUID:d8b63aba1907145bea998dd612889d6b"
     ],
     "includePlatforms": [
         "Editor"
diff --git a/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.cs b/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.cs
index 7e311cf..32c2c1b 100644
--- a/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.cs
+++ b/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.cs
@@ -16,6 +16,7 @@ public class DotsUIInspector : EditorWindow
 
     private EntityQuery m_RootQuery;
 
+    private Foldout m_CanvasProperties;
     private Foldout m_MeshProperties;
 
     [MenuItem("DotsUI/Inspector")]
@@ -44,23 +45,24 @@ public void OnEnable()
         m_ListView.onSelectionChanged += OnCanvasSelected;
 
         m_MeshProperties = ui.Q<Foldout>("MeshProperties");
+        m_CanvasProperties = ui.Q<Foldout>("CanvasProperties");
     }
 
     private void Update()
     {
-        if (World.Active != null)
+        if (World.DefaultGameObjectInjectionWorld != null)
             UpdateEntities();
     }
 
     void UpdateEntities()
     {
-        EntityManager entityManager = World.Active.EntityManager;
+        EntityManager entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
         var rootQuery = entityManager.CreateEntityQuery(new EntityQueryDesc
         {
             All = new ComponentType[]
             {
                 ComponentType.ReadOnly<DotsUI.Core.RectTransform>(),
-                ComponentType.ReadOnly<CanvasScreenSize>(),
+                ComponentType.ReadOnly<CanvasSize>(),
                 ComponentType.ReadOnly<Child>(),
                 typeof(WorldSpaceRect),
             },
@@ -80,19 +82,39 @@ void UpdateEntities()
             m_Roots.Clear();
             foreach (var root in roots)
             {
-                m_Roots.Add((entityManager.GetName(root), root));
+                m_Roots.Add((GetEntityName(entityManager, root), root));
             }
 
             m_ListView.itemsSource = m_Roots;
         }
     }
 
+    private  string GetEntityName(EntityManager manager, Entity entity)
+    {
+        string inEditorName = manager.GetName(entity);
+        return !string.IsNullOrEmpty(inEditorName) ? inEditorName : $"Entity {entity.Index}";
+    }
+
     private void OnCanvasSelected(System.Collections.Generic.List<object> obj)
     {
+        var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
         var item = ((string, Entity)) obj[0];
         m_MeshProperties.contentContainer.Clear();
-        var meshContainer = World.Active.EntityManager.GetSharedComponentData<CanvasMeshContainer>(item.Item2);
+        var meshContainer = entityManager.GetSharedComponentData<CanvasMeshContainer>(item.Item2);
         m_MeshProperties.contentContainer.Add(new Label($"Vertices: {meshContainer.UnityMesh.vertexCount}"));
         m_MeshProperties.contentContainer.Add(new Label($"SubMeshes: {meshContainer.UnityMesh.subMeshCount}"));
+
+        m_CanvasProperties.contentContainer.Clear();
+        AddEntityProperties(m_CanvasProperties, item.Item2, entityManager);
+    }
+
+    private void AddEntityProperties(Foldout propertyContainer, Entity entity, EntityManager entityManager)
+    {
+        var canvasSizeContainer = new Foldout();
+        canvasSizeContainer.text = "CanvasSize";
+        m_CanvasProperties.contentContainer.Add(canvasSizeContainer);
+
+        var canvasSize = entityManager.GetComponentData<CanvasSize>(entity);
+        canvasSizeContainer.contentContainer.Add(new Label($"{canvasSize.Value}"));
     }
 }
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.uxml b/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.uxml
index 12c3242..b837938 100644
--- a/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.uxml
+++ b/com.dotsui.core/DotsUI.Editor/Editor/DotsUIInspector.uxml
@@ -7,7 +7,8 @@
         </ui:VisualElement>
         <ui:VisualElement name="Data" style="flex-grow: 1;">
             <ui:Label text="Canvas properties" />
-            <ui:VisualElement style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgba(0, 0, 0, 255); border-right-color: rgba(0, 0, 0, 255); border-top-color: rgba(0, 0, 0, 255); border-bottom-color: rgba(0, 0, 0, 255);">
+            <ui:VisualElement style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0);">
+                <ui:Foldout text="Canvas" name="CanvasProperties" />
                 <ui:Foldout text="Mesh" name="MeshProperties" />
             </ui:VisualElement>
         </ui:VisualElement>
diff --git a/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs b/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs
index 408cfdd..1858b92 100644
--- a/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs
+++ b/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs
@@ -1,28 +1,21 @@
-using DotsUI.Core;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DotsUI.Core;
+using DotsUI.Core.Utils;
 using DotsUI.Profiling;
-using Unity.Jobs;
-using Unity.Mathematics;
 using Unity.Collections;
-using UnityEngine;
-#if UNITY_2019_3_OR_NEWER
-#else
-using UnityEngine.Experimental.PlayerLoop;
-#endif
 using Unity.Entities;
+using Unity.Jobs;
+using Unity.Mathematics;
 using Unity.Transforms;
-using RectTransform = DotsUI.Core.RectTransform;
 
 namespace DotsUI.Input
 {
-    [UpdateInGroup(typeof(InputSystemGroup))]
-    public class ControlsInputSystem : ComponentSystemGroup
-    {
-
-    }
-    [UpdateInGroup(typeof(ControlsInputSystem))]
-    [UpdateAfter(typeof(ControlsInputSystemHandler))]
-    public class ControlsInputBufferSystem : EntityCommandBufferSystem { }
-
     public enum PointerButton
     {
         Invalid = -1,
@@ -79,32 +72,45 @@ internal struct InputSystemState : IComponentData
         public Entity SelectedEntity;
     }
 
-    [UpdateInGroup(typeof(ControlsInputSystem))]
-    public class ControlsInputSystemHandler : JobComponentSystem
+    [UpdateInGroup(typeof(InputSystemGroup))]
+    public class ControlsInputSystemGroup : ComponentSystemGroup
     {
-        private EntityQuery m_RootGroup;
-        private float2 m_LastFrameMousePos;
 
+    }
 
-        private EntityArchetype m_PointerEventArchetype;
-        private EntityArchetype m_KeyboardEventArchetype;
+    [UpdateInGroup(typeof(ControlsInputSystemGroup))]
+    public class ControlsInputSystem : JobComponentSystem
+    {
+        private EntityQuery m_RootGroup;
+        private float2 m_LastFrameMousePos;
 
         private NativeArray<MouseButtonState> m_ButtonStates;
 
-        private ControlsInputBufferSystem m_CommandBufferSystem;
+        private NativeMultiHashMap<Entity, PointerInputBuffer> m_PointerTargetToEvent;
+        private NativeList<Entity> m_PointerEventList;
+        private NativeMultiHashMap<Entity, KeyboardInputBuffer> m_KeyboardTargetToEvent;
+        private NativeList<Entity> m_KeyboardEventList;
 
+        public float DragThreshold = 3.0f;
+        private NativeList<NativePointerButtonEvent> m_NativePointerEvents;
+        private NativeList<NativeKeyboardInputEvent> m_NativeKeyboardEvents;
 
-        public float DragThreshold { get; set; }
+        private NativeList<MouseInputFrameData> m_PointerFrameData;
 
         protected override void OnCreate()
         {
-            DragThreshold = 3.0f;
-            m_ButtonStates = new NativeArray<MouseButtonState>(3, Allocator.Persistent);
-            m_CommandBufferSystem = World.GetOrCreateSystem<ControlsInputBufferSystem>();
+            m_NativePointerEvents = new NativeList<NativePointerButtonEvent>(14, Allocator.Persistent);
+            m_NativeKeyboardEvents = new NativeList<NativeKeyboardInputEvent>(14, Allocator.Persistent);
 
-            m_PointerEventArchetype = EntityManager.CreateArchetype(typeof(PointerEvent), typeof(PointerInputBuffer));
-            m_KeyboardEventArchetype =
-                EntityManager.CreateArchetype(typeof(KeyboardEvent), typeof(KeyboardInputBuffer));
+            m_PointerTargetToEvent = new NativeMultiHashMap<Entity, PointerInputBuffer>(16, Allocator.Persistent);
+            m_PointerEventList = new NativeList<Entity>(16, Allocator.Persistent);
+
+            m_KeyboardTargetToEvent = new NativeMultiHashMap<Entity, KeyboardInputBuffer>(16, Allocator.Persistent);
+            m_KeyboardEventList = new NativeList<Entity>(16, Allocator.Persistent);
+
+            m_PointerFrameData = new NativeList<MouseInputFrameData>(8, Allocator.Persistent);
+
+            m_ButtonStates = new NativeArray<MouseButtonState>(3, Allocator.Persistent);
 
             m_RootGroup = GetEntityQuery(new EntityQueryDesc
             {
@@ -113,32 +119,41 @@ protected override void OnCreate()
                     ComponentType.ReadOnly<RectTransform>(),
                     ComponentType.ReadOnly<Child>(),
                     ComponentType.ReadOnly<WorldSpaceRect>(),
+                    ComponentType.ReadOnly<CanvasSortLayer>(), 
                 },
                 None = new ComponentType[]
                 {
                     typeof(Parent)
                 },
-                Options = EntityQueryOptions.FilterWriteGroup
+                Options = EntityQueryOptions.Default
             });
 
             EntityManager.CreateEntity(typeof(InputSystemState));
-            EntityManager.CreateEntity(typeof(NativePointerInputContainer), typeof(NativePointerButtonEvent), typeof(NativePointerState));
-            EntityManager.CreateEntity(typeof(NativeKeyboardInputContainer), typeof(NativeKeyboardInputEvent));
-            base.OnCreateManager();
+            //EntityManager.CreateEntity(typeof(NativePointerInputContainer), typeof(NativePointerButtonEvent), typeof(NativePointerState));
+            //EntityManager.CreateEntity(typeof(NativeKeyboardInputContainer), typeof(NativeKeyboardInputEvent));
         }
 
         protected override void OnDestroy()
         {
+            m_NativePointerEvents.Dispose();
+            m_NativeKeyboardEvents.Dispose();
+
+            m_PointerTargetToEvent.Dispose();
+            m_PointerEventList.Dispose();
+
+            m_KeyboardTargetToEvent.Dispose();
+            m_KeyboardEventList.Dispose();
+
+            m_PointerFrameData.Dispose();
+
             m_ButtonStates.Dispose();
         }
 
         protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
-            GatherEvents(Allocator.TempJob, out var pointerEvents, out var keyboardEvents);
-            var pointerFrameData = GatherPointerFrameData(Allocator.TempJob);
+            var pointerFrameData = GatherPointerFrameData(m_PointerFrameData);
             NativeArray<Entity> roots = m_RootGroup.ToEntityArray(Allocator.TempJob, out var rootsDeps);
             inputDeps = JobHandle.CombineDependencies(inputDeps, rootsDeps);
-            var profilerSample = new ProfilerSample("PrepareBuffers");
             var childrenFromEntity = GetBufferFromEntity<Child>(true);
             var worldSpaceRectFromEntity = GetComponentDataFromEntity<WorldSpaceRect>(true);
             var parentFromEntity = GetComponentDataFromEntity<Parent>(true);
@@ -150,21 +165,20 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
             NativeArray<Entity> perCanvasHits =
                 new NativeArray<Entity>(pointerFrameData.Length * roots.Length, Allocator.TempJob);
             NativeArray<Entity> globalHits = new NativeArray<Entity>(pointerFrameData.Length, Allocator.TempJob);
-            LowLevelUtils.MemSet(perCanvasHits, default);
-            LowLevelUtils.MemSet(globalHits, default);
-            profilerSample.Dispose();
+            var canvasLayerFromEntity = GetComponentDataFromEntity<CanvasSortLayer>();
 
+            m_PointerTargetToEvent.Clear();
+            m_PointerEventList.Clear();
             ProcessPerCanvasInput process = new ProcessPerCanvasInput()
             {
                 Roots = roots,
                 ChildrenFromEntity = childrenFromEntity,
                 Hits = perCanvasHits,
-                LocalToWorldFromEntity = worldSpaceRectFromEntity,
+                WorldSpaceRectFromEntity = worldSpaceRectFromEntity,
                 PointerInputReceiver = pointerReceiverFromEntity,
                 PointersPosition = pointerFrameData
             };
             inputDeps = process.Schedule(roots.Length, 1, inputDeps);
-            var canvasLayerFromEntity = GetComponentDataFromEntity<CanvasSortLayer>();
             CanvasHitsToGlobal canvasHits = new CanvasHitsToGlobal()
             {
                 Roots = roots,
@@ -173,9 +187,6 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                 PerCanvasHits = perCanvasHits
             };
             inputDeps = canvasHits.Schedule(inputDeps);
-
-            EntityCommandBuffer ecb = m_CommandBufferSystem.CreateCommandBuffer();
-            NativeMultiHashMap<Entity, PointerInputBuffer> targetToEvent = new NativeMultiHashMap<Entity, PointerInputBuffer>(16, Allocator.TempJob);
             UpdatePointerEvents updatePointerJob = new UpdatePointerEvents()
             {
                 ButtonStates = m_ButtonStates,
@@ -183,42 +194,74 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                 Hits = globalHits,
                 ReceiverFromEntity = pointerReceiverFromEntity,
                 StateFromEntity = stateComponentFromEntity,
-                PointerEvents = pointerEvents,
+                PointerEvents = m_NativePointerEvents.AsParallelReader(),
                 ParentFromEntity = parentFromEntity,
                 PointerFrameData = pointerFrameData,
                 DragThreshold = DragThreshold,
-                TargetToEvent = targetToEvent
+                TargetToEvent = m_PointerTargetToEvent,
+                PointerEventList = m_PointerEventList,
             };
             inputDeps = updatePointerJob.Schedule(inputDeps);
-            SpawnPointerEvents spawnEventsJob = new SpawnPointerEvents()
-            {
-                EventArchetype = m_PointerEventArchetype,
-                Ecb = ecb,
-                TargetToEvent = targetToEvent
-            };
-            inputDeps = spawnEventsJob.Schedule(inputDeps);
-            inputDeps = targetToEvent.Dispose(inputDeps);
             UpdateKeyboardEvents updateKeyboardJob = new UpdateKeyboardEvents()
             {
-                KeyboardEvents = keyboardEvents,
-                EventArchetype = m_KeyboardEventArchetype,
-                Manager = ecb,
+                KeyboardEvents = m_NativeKeyboardEvents.AsParallelReader(),
+                KeyboardTargetToEvent = m_KeyboardTargetToEvent,
+                KeyboardTargetList = m_KeyboardEventList,
                 StateEntity = stateEntity,
                 StateFromEntity = stateComponentFromEntity
             };
             inputDeps = updateKeyboardJob.Schedule(inputDeps);
-            m_CommandBufferSystem.AddJobHandleForProducer(inputDeps);
-            m_LastFrameMousePos = (Vector2) UnityEngine.Input.mousePosition;
+            ClearNativeBuffers clearBuffers = new ClearNativeBuffers()
+            {
+                PointerEventBuffer = m_NativePointerEvents,
+                KeyboardEventBuffer = m_NativeKeyboardEvents,
+            };
+            inputDeps = clearBuffers.Schedule(inputDeps);
+            inputDeps.Complete();
+
             return inputDeps;
         }
 
-        private NativeArray<MouseInputFrameData> GatherPointerFrameData(Allocator allocator)
+        internal NativeList<Entity> QueryPointerEvents(ComponentType requiredType, Allocator allocator)
+        {
+            return QueryListByComponent(m_PointerEventList, requiredType, allocator);
+        }
+
+        internal NativeList<Entity> QueryKeyboardEvents(ComponentType requiredType, Allocator allocator)
+        {
+            return QueryListByComponent(m_KeyboardEventList, requiredType, allocator);
+        }
+
+        NativeList<Entity> QueryListByComponent(NativeList<Entity> entityList, ComponentType requiredType, Allocator allocator)
+        {
+            NativeList<Entity> ret = new NativeList<Entity>(allocator);
+            for (int i = 0; i < entityList.Length; i++)
+            {
+                if (EntityManager.HasComponent(entityList[i], requiredType))
+                    ret.Add(entityList[i]);
+            }
+            return ret;
+        }
+
+        public NativeEventWriter GetEventWriter()
+        {
+            return new NativeEventWriter(m_NativePointerEvents, m_NativeKeyboardEvents);
+        }
+
+        /// <summary>
+        /// TODO: This function has to be refactored and moved to the Hybrid package.
+        /// </summary>
+        /// <param name="allocator"></param>
+        /// <returns></returns>
+        private NativeArray<MouseInputFrameData> GatherPointerFrameData(NativeList<MouseInputFrameData> frameData)
         {
             using (new ProfilerSample("GatherPointerFrameData"))
             {
-                NativeArray<MouseInputFrameData> ret =
-                    new NativeArray<MouseInputFrameData>(1 + UnityEngine.Input.touchCount, allocator);
-                float2 mousePos = ((float3) UnityEngine.Input.mousePosition).xy;
+                var sampl = new ProfilerSample("Reloc");
+                frameData.ResizeUninitialized(1 + UnityEngine.Input.touchCount);
+                var ret = frameData.AsArray();
+                sampl.Dispose();
+                float2 mousePos = ((float3)UnityEngine.Input.mousePosition).xy;
                 ret[0] = new MouseInputFrameData()
                 {
                     Position = mousePos,
@@ -226,7 +269,7 @@ private NativeArray<MouseInputFrameData> GatherPointerFrameData(Allocator alloca
                 };
                 for (int i = 0; i < UnityEngine.Input.touchCount; i++)
                 {
-                    Touch touch = UnityEngine.Input.GetTouch(i);
+                    UnityEngine.Touch touch = UnityEngine.Input.GetTouch(i);
                     ret[i + 1] = new MouseInputFrameData()
                     {
                         Position = touch.position,
@@ -234,51 +277,19 @@ private NativeArray<MouseInputFrameData> GatherPointerFrameData(Allocator alloca
                     };
                 }
 
+                m_LastFrameMousePos = mousePos;
                 return ret;
             }
         }
 
-        private void GatherEvents(Allocator allocator, out NativeArray<NativePointerButtonEvent> pointerEventsArray, out NativeArray<NativeKeyboardInputEvent> keyboardEventArray)
-        {
-            using(new ProfilerSample("GatherEvents"))
-            {
-                var pointerContainerEntity = GetSingletonEntity<NativePointerInputContainer>();
-                var keyboardContainerEntity = GetSingletonEntity<NativeKeyboardInputContainer>();
-
-                var pointerBuffer = EntityManager.GetBuffer<NativePointerButtonEvent>(pointerContainerEntity);
-                var keyboardBuffer = EntityManager.GetBuffer<NativeKeyboardInputEvent>(keyboardContainerEntity);
-
-                pointerEventsArray = new NativeArray<NativePointerButtonEvent>(pointerBuffer.Length, allocator);
-                keyboardEventArray = new NativeArray<NativeKeyboardInputEvent>(keyboardBuffer.Length, allocator);
-
-                for (int i = 0; i < pointerBuffer.Length; i++)
-                    pointerEventsArray[i] = pointerBuffer[i];
-
-                for (int i = 0; i < keyboardBuffer.Length; i++)
-                    keyboardEventArray[i] = keyboardBuffer[i];
-
-                pointerBuffer.Clear();
-                keyboardBuffer.Clear();
-            }
-        }
-
-        private NativeArray<float2> GatherPointersPositions(Allocator allocator)
+        internal NativeMultiHashMap<Entity, PointerInputBuffer> GetPointerEventMap()
         {
-            var ret = new NativeArray<float2>(UnityEngine.Input.touchCount + 1, allocator);
-            ret[0] = ((float3)(UnityEngine.Input.mousePosition)).xy;
-            for (int i = 0; i < UnityEngine.Input.touchCount; i++)
-            {
-                ret[i + 1] = UnityEngine.Input.GetTouch(i).position;
-            }
-
-            return ret;
+            return m_PointerTargetToEvent;
         }
 
-
-        bool IsValidKeyboardEventReceiver(Entity entity)
+        internal NativeMultiHashMap<Entity, KeyboardInputBuffer> GetKeyboardEventMap()
         {
-            return EntityManager.Exists(entity) &&
-                   EntityManager.HasComponent<KeyboardInputReceiver>(entity);
+            return m_KeyboardTargetToEvent;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs.meta b/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs.meta
index f9740f0..18e7484 100644
--- a/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs.meta
+++ b/com.dotsui.core/DotsUI.Input/ControlsInputSystem.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: bccd9d87062b0ef4d9155c2e1a06d193
+guid: 65feaf047cd387549a1a1efb1aa0c2f3
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/com.dotsui.core/DotsUI.Input/InputComponentSystem.cs b/com.dotsui.core/DotsUI.Input/InputComponentSystem.cs
deleted file mode 100644
index e50ef70..0000000
--- a/com.dotsui.core/DotsUI.Input/InputComponentSystem.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-using Unity.Burst;
-using Unity.Collections;
-using Unity.Entities;
-using Unity.Jobs;
-using DotsUI.Core;
-
-namespace DotsUI.Input
-{
-    public abstract class PointerInputComponentSystem<T> : JobComponentSystem where T : struct, IComponentData
-    {
-        private EntityQuery m_PointerEventQuery;
-        private NativeHashMap<Entity, Entity> m_TargetToEvent;
-        protected sealed override void OnCreate()
-        {
-            m_PointerEventQuery = GetEntityQuery(ComponentType.ReadOnly<PointerEvent>(), ComponentType.ReadOnly<PointerInputBuffer>());
-            m_TargetToEvent = new NativeHashMap<Entity, Entity>(10, Allocator.Persistent);
-            RequireForUpdate(m_PointerEventQuery);
-            OnCreateInput();
-        }
-
-        protected sealed override void OnDestroy()
-        {
-            m_TargetToEvent.Dispose();
-            OnDestroyInput();
-        }
-
-        [BurstCompile]
-        struct CreateTargetToEventMap : IJobChunk
-        {
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            [ReadOnly] public ArchetypeChunkComponentType<PointerEvent> EventType;
-            [ReadOnly] public ComponentDataFromEntity<T> TargetType;
-            [WriteOnly] public NativeHashMap<Entity, Entity>.ParallelWriter TargetToEvent;
-
-            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
-            {
-                var entityArray = chunk.GetNativeArray(EntityType);
-                var eventArray = chunk.GetNativeArray(EventType);
-                for (int i = 0; i < chunk.Count; i++)
-                {
-                    if (TargetType.Exists(eventArray[i].Target))
-                        TargetToEvent.TryAdd(eventArray[i].Target, entityArray[i]);
-                }
-            }
-        }
-        protected sealed override JobHandle OnUpdate(JobHandle inputDeps)
-        {
-            if (m_PointerEventQuery.CalculateEntityCount() > 0)
-            {
-                ClearHashMap<Entity, Entity> clearContainer = new ClearHashMap<Entity, Entity>()
-                {
-                    Container = m_TargetToEvent
-                };
-                inputDeps = clearContainer.Schedule(inputDeps);
-                CreateTargetToEventMap createMap = new CreateTargetToEventMap()
-                {
-                    EntityType = GetArchetypeChunkEntityType(),
-                    EventType = GetArchetypeChunkComponentType<PointerEvent>(true),
-                    TargetToEvent = m_TargetToEvent.AsParallelWriter(),
-                    TargetType = GetComponentDataFromEntity<T>(true)
-                };
-                inputDeps = createMap.Schedule(m_PointerEventQuery, inputDeps);
-                inputDeps = OnUpdateInput(inputDeps, m_TargetToEvent, GetBufferFromEntity<PointerInputBuffer>(true));
-            }
-            return inputDeps;
-        }
-
-
-        protected abstract JobHandle OnUpdateInput(JobHandle inputDeps, NativeHashMap<Entity, Entity> targetToEvent,
-            BufferFromEntity<PointerInputBuffer> pointerBufferFromEntity);
-
-        protected virtual void OnCreateInput()
-        {
-        }
-
-        protected virtual void OnDestroyInput()
-        {
-        }
-    }
-}
diff --git a/com.dotsui.core/DotsUI.Input/InputComponents.cs b/com.dotsui.core/DotsUI.Input/InputComponents.cs
index 7b50da5..6e91e0b 100644
--- a/com.dotsui.core/DotsUI.Input/InputComponents.cs
+++ b/com.dotsui.core/DotsUI.Input/InputComponents.cs
@@ -32,15 +32,6 @@ public enum PointerEventType
         Deselected = 1024,
         
         SelectableGroup = Down | Up | Click | Enter | Exit | Selected | Deselected,
-    }
-    public struct OnLostFocusEvent : IComponentData
-    {
-
-    }
-
-    public struct OnFocusEvent : IComponentData
-    {
-
     }
     public struct PointerInputReceiver : IComponentData
     {
@@ -52,16 +43,6 @@ public struct KeyboardInputReceiver : IComponentData
 
     }
 
-
-    public struct PointerEvent : IComponentData
-    {
-        public Entity Target;
-    }
-    public struct KeyboardEvent : IComponentData
-    {
-        public Entity Target;
-    }
-
     
 
     public enum KeyboardEventType
@@ -70,14 +51,18 @@ public enum KeyboardEventType
         Key
     }
 
-    public struct PointerInputBuffer : IBufferElementData
+    public interface IInputEvent
+    {
+
+    }
+    public struct PointerInputBuffer : IInputEvent
     {
         public int EventId;
         public PointerEventType EventType;
         public PointerEventData EventData;
     }
 
-    public struct KeyboardInputBuffer : IBufferElementData
+    public struct KeyboardInputBuffer : IInputEvent
     {
         public KeyboardEventType EventType;
         public ushort KeyCode;
diff --git a/com.dotsui.core/DotsUI.Input/InputDataCleanup.cs b/com.dotsui.core/DotsUI.Input/InputDataCleanup.cs
deleted file mode 100644
index e78af7b..0000000
--- a/com.dotsui.core/DotsUI.Input/InputDataCleanup.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using DotsUI.Core;
-using Unity.Entities;
-using Unity.Jobs;
-
-namespace DotsUI.Input
-{
-    [UpdateInGroup(typeof(CleanupSystemGroup))]
-    internal class InputDataCleanup : JobComponentSystem
-    {
-        private EntityQuery m_PointerGroup;
-        private EntityQuery m_FocusGroup;
-        private EntityQuery m_LostFocusGroup;
-        private EntityQuery m_KeyboardGroup;
-
-        protected override void OnCreate()
-        {
-            m_PointerGroup = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new[]
-                {
-                    ComponentType.ReadWrite<PointerInputBuffer>(),
-                    ComponentType.ReadWrite<PointerEvent>()
-                }
-            });
-            m_KeyboardGroup = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new[]
-                {
-                    ComponentType.ReadWrite<KeyboardInputBuffer>(),
-                    ComponentType.ReadWrite<KeyboardEvent>()
-                }
-            });
-            m_FocusGroup = GetEntityQuery(ComponentType.ReadWrite<OnFocusEvent>());
-            m_LostFocusGroup = GetEntityQuery(ComponentType.ReadWrite<OnLostFocusEvent>());
-        }
-
-        protected override JobHandle OnUpdate(JobHandle inputDeps)
-        {
-            EntityManager.DestroyEntity(m_PointerGroup);
-            EntityManager.DestroyEntity(m_KeyboardGroup);
-            EntityManager.RemoveComponent(m_FocusGroup, ComponentType.ReadWrite<OnFocusEvent>());
-            EntityManager.RemoveComponent(m_LostFocusGroup, ComponentType.ReadWrite<OnLostFocusEvent>());
-
-            return inputDeps;
-        }
-    }
-}
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Input/InputEventQuery.cs b/com.dotsui.core/DotsUI.Input/InputEventQuery.cs
new file mode 100644
index 0000000..7d0730a
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Input/InputEventQuery.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Jobs;
+
+namespace DotsUI.Input
+{
+    public class PointerEventQuery
+    {
+        private EntityManager m_Manager;
+        private ComponentType m_Type;
+        private ControlsInputSystem m_ControlSystem;
+
+        private PointerEventQuery(EntityManager manager, ComponentType type)
+        {
+            m_Manager = manager;
+            m_Type = type;
+            m_ControlSystem = manager.World.GetOrCreateSystem<ControlsInputSystem>();
+        }
+
+        public static PointerEventQuery Create<T>(EntityManager manager) where T : IComponentData
+        {
+            return new PointerEventQuery(manager, ComponentType.ReadOnly<T>());
+        }
+
+        public InputEventReader<PointerInputBuffer> CreatePointerEventReader(Allocator allocator)
+        {
+            var targetList = m_ControlSystem.QueryPointerEvents(m_Type, allocator);
+            return new InputEventReader<PointerInputBuffer>(targetList, m_ControlSystem.GetPointerEventMap());
+        }
+    }
+    public class KeyboardEventQuery
+    {
+        private EntityManager m_Manager;
+        private ComponentType m_Type;
+        private ControlsInputSystem m_ControlSystem;
+
+        private KeyboardEventQuery(EntityManager manager, ComponentType type)
+        {
+            m_Manager = manager;
+            m_Type = type;
+            m_ControlSystem = manager.World.GetOrCreateSystem<ControlsInputSystem>();
+        }
+
+        public static KeyboardEventQuery Create<T>(EntityManager manager) where T : IComponentData
+        {
+            return new KeyboardEventQuery(manager, ComponentType.ReadOnly<T>());
+        }
+
+        public InputEventReader<KeyboardInputBuffer> CreateKeyboardEventReader(Allocator allocator)
+        {
+            var targetList = m_ControlSystem.QueryKeyboardEvents(m_Type, allocator);
+            return new InputEventReader<KeyboardInputBuffer>(targetList, m_ControlSystem.GetKeyboardEventMap());
+        }
+    }
+
+    public struct InputEventReader<T> : IDisposable where T : struct, IInputEvent
+    {
+        [ReadOnly]
+        private NativeMultiHashMap<Entity, T> m_EventMap;
+        [ReadOnly]
+        private NativeList<Entity> m_Entities;
+        public int EntityCount => m_Entities.Length;
+        public Entity this[int idx] => m_Entities[idx];
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="entities"> allocated in PointerEventQuery</param>
+        /// <param name="eventMap"> persistent and shared between multiple queries</param>
+        internal InputEventReader(NativeList<Entity> entities,
+            NativeMultiHashMap<Entity, T> eventMap)
+        {
+            m_Entities = entities;
+            m_EventMap = eventMap;
+        }
+
+        public NativeArray<Entity> GetParallelEntityReader()
+        {
+            return m_Entities.AsParallelReader();
+        }
+        public NativeMultiHashMap<Entity, T>.Enumerator GetEventsForTargetEntity(Entity targetEntity)
+        {
+            return m_EventMap.GetValuesForKey(targetEntity);
+        }
+
+        public void GetFirstEvent(Entity entity, out T item, out NativeMultiHashMapIterator<Entity> it)
+        {
+            m_EventMap.TryGetFirstValue(entity, out item, out it);
+        }
+        public bool TryGetNextEvent(out T item, ref NativeMultiHashMapIterator<Entity> it)
+        {
+            return m_EventMap.TryGetNextValue(out item, ref it);
+        }
+
+        public void Dispose()
+        {
+            m_Entities.Dispose();
+        }
+        public JobHandle Dispose(JobHandle inputDeps)
+        {
+            return m_Entities.Dispose(inputDeps);
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Input/InputEventQuery.cs.meta b/com.dotsui.core/DotsUI.Input/InputEventQuery.cs.meta
new file mode 100644
index 0000000..1bb9a35
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Input/InputEventQuery.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8deaa5c8f0d5d844ea29a3c5ab7149bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs b/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs
new file mode 100644
index 0000000..e884fbd
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Collections;
+using Unity.Entities;
+
+namespace DotsUI.Input
+{
+    /// <summary>
+    /// This struct encapsulates internal <see cref="ControlsInputSystem"/> buffers.
+    /// These buffers are managed by <see cref="ControlsInputSystem"/> system, so we hide them behind safe wrapper.
+    /// Buffers are marked as [WriteOnly]. It's safe to use this wrapper in job.
+    /// </summary>
+    public readonly struct NativeEventWriter
+    {
+        [WriteOnly]
+        private readonly NativeList<NativePointerButtonEvent> m_PointerEventBuffer;
+        [WriteOnly]
+        private readonly NativeList<NativeKeyboardInputEvent> m_KeyboardEventBuffer;
+
+        internal NativeEventWriter(NativeList<NativePointerButtonEvent> pointerEventBuffer,
+            NativeList<NativeKeyboardInputEvent> keyboardEventBuffer)
+        {
+            m_PointerEventBuffer = pointerEventBuffer;
+            m_KeyboardEventBuffer = keyboardEventBuffer;
+        }
+        
+        /// <summary>
+        /// Add pointer event to the queue.
+        /// </summary>
+        /// <param name="pointerEvent"></param>
+        public void AddPointerEvent(NativePointerButtonEvent pointerEvent)
+        {
+            m_PointerEventBuffer.Add(pointerEvent);
+        }
+
+        /// <summary>
+        /// Add keyboard event to the queue.
+        /// </summary>
+        /// <param name="pointerEvent"></param>
+        public void AddKeyboardEvent(NativeKeyboardInputEvent keyboardEvent)
+        {
+            m_KeyboardEventBuffer.Add(keyboardEvent);
+        }
+    }
+}
diff --git a/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs.meta b/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs.meta
new file mode 100644
index 0000000..1a4de01
--- /dev/null
+++ b/com.dotsui.core/DotsUI.Input/NativeEventWriter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a8bec1000091949489e20c5353ddbe24
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.core/DotsUI.Input/ProcessPerCanvasInput.cs b/com.dotsui.core/DotsUI.Input/ProcessPerCanvasInput.cs
index e103d8e..42026d6 100644
--- a/com.dotsui.core/DotsUI.Input/ProcessPerCanvasInput.cs
+++ b/com.dotsui.core/DotsUI.Input/ProcessPerCanvasInput.cs
@@ -13,7 +13,7 @@ namespace DotsUI.Input
     internal struct ProcessPerCanvasInput : IJobParallelFor
     {
         [ReadOnly] public NativeArray<Entity> Roots;
-        [ReadOnly] public ComponentDataFromEntity<WorldSpaceRect> LocalToWorldFromEntity;
+        [ReadOnly] public ComponentDataFromEntity<WorldSpaceRect> WorldSpaceRectFromEntity;
         [ReadOnly] public ComponentDataFromEntity<PointerInputReceiver> PointerInputReceiver;
         [ReadOnly] public BufferFromEntity<Child> ChildrenFromEntity;
 
@@ -24,7 +24,8 @@ [WriteOnly] [NativeDisableContainerSafetyRestriction]
 
         public void Execute(int index)
         {
-            GoDownHierarchyTree(Roots[index], index);
+            var pointerData = PointersPosition[0];
+            GoDownHierarchyTree(Roots[index], index, pointerData.Position);
         }
 
         private bool IsInRect(ref WorldSpaceRect rect, float2 position)
@@ -33,27 +34,30 @@ private bool IsInRect(ref WorldSpaceRect rect, float2 position)
                     position.y >= rect.Min.y && position.y <= rect.Max.y);
         }
 
-        private void GoDownHierarchyTree(Entity entity, int index)
+        private bool GoDownHierarchyTree(Entity entity, int index, float2 position)
         {
-            if (PointerInputReceiver.Exists(entity) && LocalToWorldFromEntity.Exists(entity))
+            if (ChildrenFromEntity.Exists(entity))
             {
-                var localToWorld = LocalToWorldFromEntity[entity];
-
-                for (int i = 0; i < PointersPosition.Length; i++)
+                var children = ChildrenFromEntity[entity];
+                for (int i = children.Length-1; i >= 0; i--)
                 {
-                    if (IsInRect(ref localToWorld, PointersPosition[i].Position))
-                        Hits[index * PointersPosition.Length + i] = entity;
+                    if (GoDownHierarchyTree(children[i].Value, index, position))
+                        return true;
                 }
             }
 
-            if (ChildrenFromEntity.Exists(entity))
+            if (PointerInputReceiver.Exists(entity) && WorldSpaceRectFromEntity.Exists(entity))
             {
-                var children = ChildrenFromEntity[entity];
-                for (int i = 0; i < children.Length; i++)
+                var localToWorld = WorldSpaceRectFromEntity[entity];
+
+                if (IsInRect(ref localToWorld, position))
                 {
-                    GoDownHierarchyTree(children[i].Value, index);
+                    Hits[index * PointersPosition.Length] = entity;
+                    return true;
                 }
             }
+
+            return false;
         }
     }
 }
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Input/SelectableSystem.cs b/com.dotsui.core/DotsUI.Input/SelectableSystem.cs
index 973c3f6..e99b71d 100644
--- a/com.dotsui.core/DotsUI.Input/SelectableSystem.cs
+++ b/com.dotsui.core/DotsUI.Input/SelectableSystem.cs
@@ -1,3 +1,4 @@
+using System.Drawing;
 using DotsUI.Core;
 using DotsUI.Core.Utils;
 using Unity.Burst;
@@ -9,14 +10,15 @@
 namespace DotsUI.Input
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateAfter(typeof(ControlsInputSystem))]
-    public class SelectableSystem : PointerInputComponentSystem<Selectable>
+    [UpdateAfter(typeof(ControlsInputSystemGroup))]
+    public class SelectableSystem : JobComponentSystem
     {
         private EntityQuery m_SelectableGroup;
 
         private InputHandleBarrier m_Barrier;
+        private PointerEventQuery m_EventQuery;
 
-        protected override void OnCreateInput()
+        protected override void OnCreate()
         {
             m_Barrier = World.GetOrCreateSystem<InputHandleBarrier>();
             m_SelectableGroup = GetEntityQuery(new EntityQueryDesc()
@@ -28,114 +30,122 @@ protected override void OnCreateInput()
                     ComponentType.ReadWrite<VertexColorValue>()
                 }
             });
+            m_EventQuery = PointerEventQuery.Create<Selectable>(EntityManager);
             RequireForUpdate(m_SelectableGroup);
         }
 
-        protected override void OnDestroyInput()
+        protected override void OnDestroy()
         {
         }
 
         [BurstCompile]
         struct SetColorValueJob : IJobChunk
         {
-            [ReadOnly] public ArchetypeChunkComponentType<SelectableColor> SelectableColorType;
-            public ArchetypeChunkComponentType<Selectable> SelectableType;
-            [ReadOnly] public ArchetypeChunkEntityType EntityType;
-            [ReadOnly] public BufferFromEntity<PointerInputBuffer> PointerInputType;
-            [ReadOnly] public NativeHashMap<Entity, Entity> TargetToEvent;
+            [ReadOnly] public ComponentDataFromEntity<SelectableColor> SelectableColorType;
+            [NativeDisableParallelForRestriction] public ComponentDataFromEntity<Selectable> SelectableType;
 
             // This is probably not the best idea to disable this restriction, since different selecatables can point to the same target
             [NativeDisableParallelForRestriction] public ComponentDataFromEntity<VertexColorMultiplier> ColorMultiplierFromEntity;
-            public AddFlagComponentCommandBuffer.ParallelWriter ToUpdate;
+            public FlagComponentCommandBuffer.ParallelWriter ToUpdate;
+            public InputEventReader<PointerInputBuffer> EventReader;
 
             public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
             {
-                var selectableColorArray = chunk.GetNativeArray(SelectableColorType);
-                var selectableArray = chunk.GetNativeArray(SelectableType);
-                var entityArray = chunk.GetNativeArray(EntityType);
 
-                for (int i = 0; i < chunk.Count; i++)
+                for (int i = 0; i < EventReader.EntityCount; i++)
                 {
-                    var selectableState = selectableArray[i];
+                    var entity = EventReader[i];
+                    var selectableColor = SelectableColorType[entity];
+                    var selectableState = SelectableType[entity];
 
-                    if (TargetToEvent.TryGetValue(entityArray[i], out Entity eventEntity))
-                    {
-                        var inputBuffer = PointerInputType[eventEntity];
-                        for (int j = 0; j < inputBuffer.Length; j++)
-                        {
-                            var input = inputBuffer[j];
-                            if (input.EventType == PointerEventType.Down && input.EventData.Button == PointerButton.Left)
-                                selectableState.Value |= SelectableState.Pressed;
-                            else if (input.EventType == PointerEventType.Up && input.EventData.Button == PointerButton.Left)
-                                selectableState.Value &= (~SelectableState.Pressed);
-                            else if (input.EventType == PointerEventType.Enter)
-                                selectableState.Value |= SelectableState.Hovered;
-                            else if (input.EventType == PointerEventType.Exit)
-                                selectableState.Value &= (~SelectableState.Hovered);
-                            else if (input.EventType == PointerEventType.Selected)
-                                selectableState.Value |= SelectableState.Selected;
-                            else if (input.EventType == PointerEventType.Deselected)
-                                selectableState.Value &= (~SelectableState.Selected);
-                        }
-                    }
+                    selectableState = ParseEntityEvents(entity, selectableState);
 
-                    var target = selectableColorArray[i].Target;
+                    var target = selectableColor.Target;
                     if (ColorMultiplierFromEntity.Exists(target))
                     {
                         var currentColor = ColorMultiplierFromEntity[target].Value;
                         float4 newColor = currentColor;
                         if ((selectableState.Value & SelectableState.Pressed) == SelectableState.Pressed)
                         {
-                            newColor = selectableColorArray[i].Pressed;
+                            newColor = selectableColor.Pressed;
                         }
                         else if ((selectableState.Value & SelectableState.Selected) == SelectableState.Selected)
                         {
-                            newColor = selectableColorArray[i].Selected;
+                            newColor = selectableColor.Selected;
                         }
                         else if ((selectableState.Value & SelectableState.Hovered) == SelectableState.Hovered)
                         {
-                            newColor = selectableColorArray[i].Hover;
+                            newColor = selectableColor.Hover;
                         }
                         else
                         {
-                            newColor = selectableColorArray[i].Normal;
+                            newColor = selectableColor.Normal;
                         }
 
                         if (!currentColor.Equals(newColor))
                         {
-                            ColorMultiplierFromEntity[selectableColorArray[i].Target] = new VertexColorMultiplier()
+                            ColorMultiplierFromEntity[selectableColor.Target] = new VertexColorMultiplier()
                             {
                                 Value = newColor
                             };
                         }
 
                         ToUpdate.TryAdd(target);
-                        selectableArray[i] = selectableState;
                     }
 
+                    SelectableType[entity] = selectableState;
                 }
+
+            }
+
+            private Selectable ParseEntityEvents(Entity entity, Selectable selectableState)
+            {
+                EventReader.GetFirstEvent(entity, out var pointerEvent, out var it);
+                do
+                {
+                    selectableState = ParseEvent(pointerEvent, selectableState);
+                } while (EventReader.TryGetNextEvent(out pointerEvent, ref it));
+                return selectableState;
+            }
+
+            private static Selectable ParseEvent(PointerInputBuffer pointerEvent, Selectable selectableState)
+            {
+                if (pointerEvent.EventType == PointerEventType.Down && pointerEvent.EventData.Button == PointerButton.Left)
+                    selectableState.Value |= SelectableState.Pressed;
+                else if (pointerEvent.EventType == PointerEventType.Up && pointerEvent.EventData.Button == PointerButton.Left)
+                    selectableState.Value &= (~SelectableState.Pressed);
+                else if (pointerEvent.EventType == PointerEventType.Enter)
+                    selectableState.Value |= SelectableState.Hovered;
+                else if (pointerEvent.EventType == PointerEventType.Exit)
+                    selectableState.Value &= (~SelectableState.Hovered);
+                else if (pointerEvent.EventType == PointerEventType.Selected)
+                    selectableState.Value |= SelectableState.Selected;
+                else if (pointerEvent.EventType == PointerEventType.Deselected)
+                    selectableState.Value &= (~SelectableState.Selected);
+                return selectableState;
             }
         };
-        protected override JobHandle OnUpdateInput(JobHandle inputDeps, NativeHashMap<Entity, Entity> targetToEvent, BufferFromEntity<PointerInputBuffer> pointerBufferFromEntity)
+        protected override JobHandle OnUpdate(JobHandle inputDeps)
         {
-            var selectableColorType = GetArchetypeChunkComponentType<SelectableColor>(true);
-            var selectableType = GetArchetypeChunkComponentType<Selectable>();
-            var entityType = GetArchetypeChunkEntityType();
-
-            NativeHashMap<Entity, int> updateQueue = new NativeHashMap<Entity, int>(m_SelectableGroup.CalculateEntityCount(), Allocator.TempJob);
-            SetColorValueJob setJob = new SetColorValueJob()
+            var eventReader = m_EventQuery.CreatePointerEventReader(Allocator.TempJob);
+            if (eventReader.EntityCount> 0)
             {
-                SelectableColorType = selectableColorType,
-                SelectableType = selectableType,
-                ColorMultiplierFromEntity = GetComponentDataFromEntity<VertexColorMultiplier>(),
-                EntityType = entityType,
-                PointerInputType = pointerBufferFromEntity,
-                TargetToEvent = targetToEvent,
-                ToUpdate = m_Barrier.CreateAddFlagComponentCommandBuffer<UpdateElementColor>().AsParallelWriter()
-            };
-            inputDeps = setJob.Schedule(m_SelectableGroup, inputDeps);
-            m_Barrier.AddJobHandleForProducer(inputDeps);
-            inputDeps = updateQueue.Dispose(inputDeps);
+
+                NativeHashMap<Entity, int> updateQueue =
+                    new NativeHashMap<Entity, int>(m_SelectableGroup.CalculateEntityCount(), Allocator.TempJob);
+                SetColorValueJob setJob = new SetColorValueJob()
+                {
+                    SelectableColorType = GetComponentDataFromEntity<SelectableColor>(true),
+                    SelectableType = GetComponentDataFromEntity<Selectable>(),
+                    ColorMultiplierFromEntity = GetComponentDataFromEntity<VertexColorMultiplier>(),
+                    EventReader = eventReader,
+                    ToUpdate = m_Barrier.CreateFlagComponentCommandBuffer<UpdateElementColor>().AsParallelWriter()
+                };
+                inputDeps = setJob.Schedule(m_SelectableGroup, inputDeps);
+                m_Barrier.AddJobHandleForProducer(inputDeps);
+                inputDeps = updateQueue.Dispose(inputDeps);
+            }
+            inputDeps = eventReader.Dispose(inputDeps);
             return inputDeps;
         }
     }
diff --git a/com.dotsui.core/DotsUI.Input/UpdateKeyboardEvents.cs b/com.dotsui.core/DotsUI.Input/UpdateKeyboardEvents.cs
index 5162ece..63b61d0 100644
--- a/com.dotsui.core/DotsUI.Input/UpdateKeyboardEvents.cs
+++ b/com.dotsui.core/DotsUI.Input/UpdateKeyboardEvents.cs
@@ -1,44 +1,46 @@
+using Unity.Burst;
 using Unity.Collections;
 using Unity.Entities;
 using Unity.Jobs;
 
 namespace DotsUI.Input
 {
+    [BurstCompile]
     internal struct UpdateKeyboardEvents : IJob
     {
-        [ReadOnly] [DeallocateOnJobCompletion] public NativeArray<NativeKeyboardInputEvent> KeyboardEvents;
+        [ReadOnly] public NativeArray<NativeKeyboardInputEvent> KeyboardEvents;
         [ReadOnly] public ComponentDataFromEntity<InputSystemState> StateFromEntity;
         [ReadOnly] public Entity StateEntity;
-        public EntityCommandBuffer Manager;
-        public EntityArchetype EventArchetype;
+        public NativeMultiHashMap<Entity, KeyboardInputBuffer> KeyboardTargetToEvent;
+        public NativeList<Entity> KeyboardTargetList;
 
         public void Execute()
         {
             var state = StateFromEntity[StateEntity];
-
+            KeyboardTargetToEvent.Clear();
+            KeyboardTargetList.Clear();
+            // Same as we did in pointer events
+            var uniqueTargets = new NativeHashMap<Entity, int>(KeyboardEvents.Length, Allocator.Temp);
             if (KeyboardEvents.Length > 0)
             {
                 var selected = state.SelectedEntity;
                 if (selected != default)
                 {
-                    var eventEntity = Manager.CreateEntity(EventArchetype);
-                    var buff = Manager.SetBuffer<KeyboardInputBuffer>(eventEntity);
-                    Manager.SetComponent(eventEntity, new KeyboardEvent()
-                    {
-                        Target = selected
-                    });
                     for (int i = 0; i < KeyboardEvents.Length; i++)
                     {
                         if (KeyboardEvents[i].EventType == NativeInputEventType.KeyDown)
-                            buff.Add(new KeyboardInputBuffer()
+                            KeyboardTargetToEvent.Add(selected, new KeyboardInputBuffer()
                             {
                                 Character = KeyboardEvents[i].Character,
                                 EventType = KeyboardEvents[i].KbdEvent,
                                 KeyCode = KeyboardEvents[i].KeyCode
                             });
+                        uniqueTargets.TryAdd(selected, 0);
                     }
                 }
             }
+            KeyboardTargetList.AddRange(uniqueTargets.GetKeyArray(Allocator.Temp));
+            uniqueTargets.Dispose();
         }
     }
 }
\ No newline at end of file
diff --git a/com.dotsui.core/DotsUI.Input/UpdatePointerEvents.cs b/com.dotsui.core/DotsUI.Input/UpdatePointerEvents.cs
index 0b8c3a9..13e278b 100644
--- a/com.dotsui.core/DotsUI.Input/UpdatePointerEvents.cs
+++ b/com.dotsui.core/DotsUI.Input/UpdatePointerEvents.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using Unity.Burst;
 using Unity.Collections;
 using Unity.Entities;
@@ -8,45 +7,18 @@
 
 namespace DotsUI.Input
 {
-    internal struct SpawnPointerEvents : IJob
+    [BurstCompile]
+    struct ClearNativeBuffers : IJob
     {
-        [ReadOnly] public NativeMultiHashMap<Entity,  PointerInputBuffer> TargetToEvent;
-        public EntityCommandBuffer Ecb;
-        public EntityArchetype EventArchetype;
-
-        struct EventComparer : IComparer< PointerInputBuffer>
-        {
-            public int Compare(PointerInputBuffer x, PointerInputBuffer y) => x.EventId.CompareTo(y.EventId);
-        }
+        [WriteOnly]
+        public NativeList<NativePointerButtonEvent> PointerEventBuffer;
+        [WriteOnly]
+        public NativeList<NativeKeyboardInputEvent> KeyboardEventBuffer;
 
         public void Execute()
         {
-            var targets = TargetToEvent.GetKeyArray(Allocator.Temp);
-            NativeList<PointerInputBuffer> eventList = new NativeList<PointerInputBuffer>(4, Allocator.Temp);
-            for (int i = 0; i < targets.Length; i++)
-            {
-                var target = targets[i];
-                EventComparer eventComparer = new EventComparer();
-                if (TargetToEvent.TryGetFirstValue(target, out var item, out var it))
-                {
-                    var eventEntity = Ecb.CreateEntity(EventArchetype);
-                    Ecb.SetComponent(eventEntity, new PointerEvent
-                    {
-                        Target = target
-                    });
-                    var buffer = Ecb.SetBuffer<PointerInputBuffer>(eventEntity);
-                    do
-                    {
-                        eventList.Add(item);
-                    } while (TargetToEvent.TryGetNextValue(out item, ref it));
-                    eventList.Sort(eventComparer);
-                    buffer.ResizeUninitialized(eventList.Length);
-                    for (int j = 0; j < eventList.Length; j++)
-                        buffer[j] = eventList[j];
-                    eventList.Clear();
-                    eventList.Clear();
-                }
-            }
+            PointerEventBuffer.Clear();
+            KeyboardEventBuffer.Clear();
         }
     }
     [BurstCompile]
@@ -54,10 +26,9 @@ internal struct UpdatePointerEvents : IJob
     {
         [ReadOnly] public Entity StateEntity;
         [ReadOnly] [DeallocateOnJobCompletion] public NativeArray<Entity> Hits;
-        [ReadOnly] [DeallocateOnJobCompletion] public NativeArray<MouseInputFrameData> PointerFrameData;
+        [ReadOnly] public NativeArray<MouseInputFrameData> PointerFrameData;
 
         [ReadOnly]
-        [DeallocateOnJobCompletion]
         public NativeArray<NativePointerButtonEvent> PointerEvents;
 
         public NativeArray<MouseButtonState> ButtonStates;
@@ -67,6 +38,7 @@ internal struct UpdatePointerEvents : IJob
         [ReadOnly] public float DragThreshold;
 
         public NativeMultiHashMap<Entity, PointerInputBuffer> TargetToEvent;
+        public NativeList<Entity> PointerEventList;
 
         // used to preserve order in NativeMultiHashMap
         private int m_EventIdCounter;
@@ -75,6 +47,7 @@ public void Execute()
         {
             m_EventIdCounter = 0;
             TargetToEvent.Clear();
+            PointerEventList.Clear();
             var state = StateFromEntity[StateEntity];
             // Currently only mouse is fully supported. That's why I pick only the first hit entity (mouse) and skip touches
             Entity mouseHit = Hits[0];
@@ -82,6 +55,22 @@ public void Execute()
             UpdateButtons(mouseHit, ref state);
             UpdateDrag(mouseHit, ref state);
             StateFromEntity[StateEntity] = state;
+            SaveTargetList();
+        }
+
+        private void SaveTargetList()
+        {
+            // NativeMultiHashMap duplicates keys. We need unique key list
+            // TODO: Need more efficient implementation
+            var tempKeyArray = TargetToEvent.GetKeyArray(Allocator.Temp);
+            var uniqueMap = new NativeHashMap<Entity, int>(tempKeyArray.Length, Allocator.Temp);
+            for (int i = 0; i < tempKeyArray.Length; i++)
+            {
+                uniqueMap.TryAdd(tempKeyArray[i], 0);
+            }
+            PointerEventList.AddRange(uniqueMap.GetKeyArray(Allocator.Temp));
+            tempKeyArray.Dispose();
+            uniqueMap.Dispose();
         }
 
         private void UpdateDrag(Entity mouseHit, ref InputSystemState state)
diff --git a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.cs b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.cs
index 400dcca..36625bc 100644
--- a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.cs
+++ b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.cs
@@ -12,12 +12,12 @@ public class PrefabExample : MonoBehaviour
     // Start is called before the first frame update
     void Start()
     {
-        if (World.Active == null)
+        if (World.DefaultGameObjectInjectionWorld == null)
             DefaultWorldInitialization.Initialize("UI World", false);
         //var entityManager = World.Active.EntityManager;
 
-        World.Active.GetOrCreateSystem<UserInputSystemGroup>().AddSystemToUpdateList(World.Active.GetOrCreateSystem<InstantiationSystem>());
-        World.Active.GetOrCreateSystem<UserInputSystemGroup>().AddSystemToUpdateList(World.Active.GetOrCreateSystem<CloseButtonSystem>());
+        World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<UserInputSystemGroup>().AddSystemToUpdateList(World.Active.GetOrCreateSystem<InstantiationSystem>());
+        World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<UserInputSystemGroup>().AddSystemToUpdateList(World.Active.GetOrCreateSystem<CloseButtonSystem>());
 
         //RectTransformToEntity transformToEntity = new RectTransformToEntity(100, Allocator.Temp);
         //RectTransformConversionUtils.ConvertCanvasHierarchy(m_TopCanvas, World.Active.EntityManager, transformToEntity);
diff --git a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.unity b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.unity
index c001b91..706b5f5 100644
--- a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.unity
+++ b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample.unity
@@ -121,6 +121,177 @@ NavMeshSettings:
     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
+--- !u!1 &386034
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 386035}
+  - component: {fileID: 386038}
+  - component: {fileID: 386037}
+  - component: {fileID: 386036}
+  m_Layer: 5
+  m_Name: InputField (TMP)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &386035
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 386034}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1395040733}
+  m_Father: {fileID: 2045108541}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0.000015258789, y: 0}
+  m_Pivot: {x: 1, y: 0.5}
+--- !u!114 &386036
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 386034}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 2da0c512f12947e489f739169773d7ca, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 386037}
+  m_TextViewport: {fileID: 1395040733}
+  m_TextComponent: {fileID: 1679846699}
+  m_Placeholder: {fileID: 1246550223}
+  m_VerticalScrollbar: {fileID: 0}
+  m_VerticalScrollbarEventHandler: {fileID: 0}
+  m_ScrollSensitivity: 1
+  m_ContentType: 0
+  m_InputType: 0
+  m_AsteriskChar: 42
+  m_KeyboardType: 0
+  m_LineType: 0
+  m_HideMobileInput: 0
+  m_HideSoftKeyboard: 0
+  m_CharacterValidation: 0
+  m_RegexValue: 
+  m_GlobalPointSize: 14
+  m_CharacterLimit: 0
+  m_OnEndEdit:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnSubmit:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnSelect:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnDeselect:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnTextSelection:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnEndTextSelection:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnValueChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_OnTouchScreenKeyboardStatusChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_CustomCaretColor: 0
+  m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412}
+  m_Text: 
+  m_CaretBlinkRate: 0.85
+  m_CaretWidth: 1
+  m_ReadOnly: 0
+  m_RichText: 1
+  m_GlobalFontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_OnFocusSelectAll: 1
+  m_ResetOnDeActivation: 1
+  m_RestoreOriginalTextOnEscape: 1
+  m_isRichTextEditingAllowed: 0
+  m_LineLimit: 0
+  m_InputValidator: {fileID: 0}
+--- !u!114 &386037
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 386034}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10911, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &386038
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 386034}
+  m_CullTransparentMesh: 0
 --- !u!1 &60727047
 GameObject:
   m_ObjectHideFlags: 0
@@ -276,53 +447,7 @@ CanvasRenderer:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 60727047}
   m_CullTransparentMesh: 0
---- !u!1 &199182780
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 199182781}
-  - component: {fileID: 199182782}
-  m_Layer: 0
-  m_Name: UI_INITIALIZER
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &199182781
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 199182780}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 1036.6141, y: 496.98425, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 2
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &199182782
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 199182780}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: b6bd56c19ade7e148871c6591a80c60b, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  m_TopCanvas: {fileID: 0}
-  m_RightCanvas: {fileID: 0}
-  m_PrefabDestination: {fileID: 707330896}
---- !u!1 &449388185
+--- !u!1 &191346122
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -330,26 +455,25 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 449388189}
-  - component: {fileID: 449388188}
-  - component: {fileID: 449388187}
-  - component: {fileID: 449388186}
-  - component: {fileID: 449388190}
-  - component: {fileID: 449388191}
+  - component: {fileID: 191346126}
+  - component: {fileID: 191346125}
+  - component: {fileID: 191346124}
+  - component: {fileID: 191346123}
+  - component: {fileID: 191346127}
   m_Layer: 5
-  m_Name: FpsCounter
+  m_Name: RightPanel
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!114 &449388186
+--- !u!114 &191346123
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
+  m_GameObject: {fileID: 191346122}
   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
@@ -360,13 +484,13 @@ MonoBehaviour:
   m_BlockingMask:
     serializedVersion: 2
     m_Bits: 4294967295
---- !u!114 &449388187
+--- !u!114 &191346124
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
+  m_GameObject: {fileID: 191346122}
   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
@@ -382,17 +506,17 @@ MonoBehaviour:
   m_FallbackScreenDPI: 96
   m_DefaultSpriteDPI: 96
   m_DynamicPixelsPerUnit: 1
---- !u!223 &449388188
+--- !u!223 &191346125
 Canvas:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
+  m_GameObject: {fileID: 191346122}
   m_Enabled: 1
   serializedVersion: 3
   m_RenderMode: 0
-  m_Camera: {fileID: 1399202792}
+  m_Camera: {fileID: 0}
   m_PlaneDistance: 100
   m_PixelPerfect: 0
   m_ReceivesEvents: 1
@@ -403,53 +527,40 @@ Canvas:
   m_SortingLayerID: 0
   m_SortingOrder: 0
   m_TargetDisplay: 0
---- !u!224 &449388189
+--- !u!224 &191346126
 RectTransform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
+  m_GameObject: {fileID: 191346122}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 0, y: 0, z: 0}
   m_Children:
-  - {fileID: 60727048}
+  - {fileID: 1109214825}
   m_Father: {fileID: 0}
-  m_RootOrder: 0
+  m_RootOrder: 5
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
   m_AnchorMax: {x: 0, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0, y: 0}
---- !u!114 &449388190
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 0a47bb6e157dfcd4c842c1841191393d, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  TargetText: {fileID: 60727048}
---- !u!114 &449388191
+--- !u!114 &191346127
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 449388185}
+  m_GameObject: {fileID: 191346122}
   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: ea7d7495833204790ba1d3a8755397f8, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
   ConversionMode: 0
---- !u!1 &629456525
+--- !u!1 &199182780
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -457,89 +568,45 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 629456527}
-  - component: {fileID: 629456526}
+  - component: {fileID: 199182781}
+  - component: {fileID: 199182782}
   m_Layer: 0
-  m_Name: ScreenSpaceOverlayGUIProxy_DO_NOT_DESTROY
+  m_Name: UI_INITIALIZER
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!114 &629456526
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 629456525}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 22c71c675ee33cb4f9376677c9652617, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
---- !u!4 &629456527
+--- !u!4 &199182781
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 629456525}
+  m_GameObject: {fileID: 199182780}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalPosition: {x: 1036.6141, y: 496.98425, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 7
+  m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &642999933
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 642999935}
-  - component: {fileID: 642999934}
-  m_Layer: 0
-  m_Name: RightPanel
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!114 &642999934
+--- !u!114 &199182782
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 642999933}
+  m_GameObject: {fileID: 199182780}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 45a335734b1572644a6a5d09d87adc65, type: 3}
+  m_Script: {fileID: 11500000, guid: b6bd56c19ade7e148871c6591a80c60b, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  _SceneAsset: {fileID: 102900000, guid: e70dd9de098550d408a750a7625c962b, type: 3}
-  _HierarchyColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
-  AutoLoadScene: 1
-  m_SubSceneHeader: {fileID: 11400000, guid: fcca63edf5a091c44ae28a8a2094c5f2, type: 2}
---- !u!4 &642999935
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 642999933}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 5
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &707330893
+  m_TopCanvas: {fileID: 0}
+  m_RightCanvas: {fileID: 0}
+  m_PrefabDestination: {fileID: 707330896}
+--- !u!1 &249243414
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -547,124 +614,1661 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 707330897}
-  - component: {fileID: 707330896}
-  - component: {fileID: 707330895}
-  - component: {fileID: 707330894}
-  - component: {fileID: 707330898}
-  - component: {fileID: 707330899}
+  - component: {fileID: 249243415}
+  - component: {fileID: 249243417}
+  - component: {fileID: 249243416}
   m_Layer: 5
-  m_Name: WindowCanvas
+  m_Name: Text (TMP)
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!114 &707330894
-MonoBehaviour:
+--- !u!224 &249243415
+RectTransform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  m_IgnoreReversedGraphics: 1
-  m_BlockingObjects: 0
-  m_BlockingMask:
-    serializedVersion: 2
-    m_Bits: 4294967295
---- !u!114 &707330895
+  m_GameObject: {fileID: 249243414}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1559862516}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0.5, y: 1}
+  m_AnchoredPosition: {x: 1, y: 0}
+  m_SizeDelta: {x: -1, y: 0}
+  m_Pivot: {x: 0, y: 0.5}
+--- !u!114 &249243416
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
+  m_GameObject: {fileID: 249243414}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_UiScaleMode: 2
-  m_ReferencePixelsPerUnit: 100
-  m_ScaleFactor: 1
-  m_ReferenceResolution: {x: 800, y: 600}
-  m_ScreenMatchMode: 0
-  m_MatchWidthOrHeight: 0
-  m_PhysicalUnit: 1
-  m_FallbackScreenDPI: 96
-  m_DefaultSpriteDPI: 96
-  m_DynamicPixelsPerUnit: 1
---- !u!223 &707330896
-Canvas:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: Slider
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontColor: {r: 1, g: 1, b: 1, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_outlineColor:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontSize: 4
+  m_fontSizeBase: 4
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_textAlignment: 513
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_firstOverflowCharacterIndex: -1
+  m_linkedTextComponent: {fileID: 0}
+  m_isLinkedTextComponent: 0
+  m_isTextTruncated: 0
+  m_enableKerning: 1
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_ignoreRectMaskCulling: 0
+  m_ignoreCulling: 1
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_VertexBufferAutoSizeReduction: 1
+  m_firstVisibleCharacter: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_textInfo:
+    textComponent: {fileID: 249243416}
+    characterCount: 6
+    spriteCount: 0
+    spaceCount: 0
+    wordCount: 1
+    linkCount: 0
+    lineCount: 1
+    pageCount: 1
+    materialCount: 1
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_spriteAnimator: {fileID: 0}
+  m_hasFontAssetChanged: 0
+  m_subTextObjects:
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &249243417
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 249243414}
+  m_CullTransparentMesh: 0
+--- !u!1 &342594873
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 342594874}
+  - component: {fileID: 342594876}
+  - component: {fileID: 342594875}
+  m_Layer: 5
+  m_Name: Text (TMP)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &342594874
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 342594873}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2045108541}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0.5, y: 1}
+  m_AnchoredPosition: {x: 1, y: 0}
+  m_SizeDelta: {x: -1, y: 0}
+  m_Pivot: {x: 0, y: 0.5}
+--- !u!114 &342594875
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 342594873}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: Input field
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontColor: {r: 1, g: 1, b: 1, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_outlineColor:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontSize: 4
+  m_fontSizeBase: 4
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_textAlignment: 513
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_firstOverflowCharacterIndex: -1
+  m_linkedTextComponent: {fileID: 0}
+  m_isLinkedTextComponent: 0
+  m_isTextTruncated: 0
+  m_enableKerning: 1
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_ignoreRectMaskCulling: 0
+  m_ignoreCulling: 1
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_VertexBufferAutoSizeReduction: 1
+  m_firstVisibleCharacter: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_textInfo:
+    textComponent: {fileID: 342594875}
+    characterCount: 11
+    spriteCount: 0
+    spaceCount: 1
+    wordCount: 2
+    linkCount: 0
+    lineCount: 1
+    pageCount: 1
+    materialCount: 1
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_spriteAnimator: {fileID: 0}
+  m_hasFontAssetChanged: 0
+  m_subTextObjects:
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &342594876
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 342594873}
+  m_CullTransparentMesh: 0
+--- !u!1 &449388185
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 449388189}
+  - component: {fileID: 449388188}
+  - component: {fileID: 449388187}
+  - component: {fileID: 449388186}
+  - component: {fileID: 449388190}
+  - component: {fileID: 449388191}
+  m_Layer: 5
+  m_Name: FpsCounter
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &449388186
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &449388187
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 2
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 1
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &449388188
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 1399202792}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 25
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &449388189
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 60727048}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!114 &449388190
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0a47bb6e157dfcd4c842c1841191393d, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  TargetText: {fileID: 60727048}
+--- !u!114 &449388191
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 449388185}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ea7d7495833204790ba1d3a8755397f8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ConversionMode: 0
+--- !u!1 &707330893
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 707330897}
+  - component: {fileID: 707330896}
+  - component: {fileID: 707330895}
+  - component: {fileID: 707330894}
+  - component: {fileID: 707330898}
+  - component: {fileID: 707330899}
+  m_Layer: 5
+  m_Name: WindowCanvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &707330894
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &707330895
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 2
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 1
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &707330896
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 1399202792}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 25
+  m_SortingLayerID: 0
+  m_SortingOrder: 10
+  m_TargetDisplay: 0
+--- !u!224 &707330897
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!114 &707330898
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 139c5c0e28dc67c40ad0ac4da3e551fc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!114 &707330899
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 707330893}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ea7d7495833204790ba1d3a8755397f8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ConversionMode: 0
+--- !u!1 &740286395
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 740286396}
+  m_Layer: 5
+  m_Name: Handle Slide Area
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &740286396
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 740286395}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 808257676}
+  m_Father: {fileID: 1743066982}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.25}
+  m_AnchorMax: {x: 1, y: 0.75}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: -20, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!1 &808257675
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 808257676}
+  - component: {fileID: 808257678}
+  - component: {fileID: 808257677}
+  m_Layer: 5
+  m_Name: Handle
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &808257676
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 808257675}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 740286396}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 5, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &808257677
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 808257675}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10913, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &808257678
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 808257675}
+  m_CullTransparentMesh: 0
+--- !u!1 &849133206
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 849133207}
+  - component: {fileID: 849133209}
+  - component: {fileID: 849133208}
+  m_Layer: 5
+  m_Name: Background
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &849133207
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 849133206}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1743066982}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.35}
+  m_AnchorMax: {x: 1, y: 0.65}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &849133208
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 849133206}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10907, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &849133209
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 849133206}
+  m_CullTransparentMesh: 0
+--- !u!1 &1109214824
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1109214825}
+  - component: {fileID: 1109214827}
+  - component: {fileID: 1109214826}
+  m_Layer: 5
+  m_Name: PanelFrame
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1109214825
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1109214824}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1838958203}
+  - {fileID: 2045108541}
+  - {fileID: 1559862516}
+  m_Father: {fileID: 191346126}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 1, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: -3}
+  m_SizeDelta: {x: 60, y: -6}
+  m_Pivot: {x: 1, y: 0.5}
+--- !u!114 &1109214826
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1109214824}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.18867922, g: 0.18867922, b: 0.18867922, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &1109214827
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1109214824}
+  m_CullTransparentMesh: 0
+--- !u!1 &1246550221
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1246550222}
+  - component: {fileID: 1246550224}
+  - component: {fileID: 1246550223}
+  m_Layer: 5
+  m_Name: Placeholder
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1246550222
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1246550221}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1395040733}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1246550223
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1246550221}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: Enter text...
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 2150773298
+  m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 0.5}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_outlineColor:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontSize: 4
+  m_fontSizeBase: 4
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 2
+  m_textAlignment: 513
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 0
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_firstOverflowCharacterIndex: -1
+  m_linkedTextComponent: {fileID: 0}
+  m_isLinkedTextComponent: 0
+  m_isTextTruncated: 0
+  m_enableKerning: 1
+  m_enableExtraPadding: 1
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_ignoreRectMaskCulling: 0
+  m_ignoreCulling: 1
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_VertexBufferAutoSizeReduction: 1
+  m_firstVisibleCharacter: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_textInfo:
+    textComponent: {fileID: 1246550223}
+    characterCount: 13
+    spriteCount: 0
+    spaceCount: 1
+    wordCount: 2
+    linkCount: 0
+    lineCount: 1
+    pageCount: 1
+    materialCount: 1
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_spriteAnimator: {fileID: 0}
+  m_hasFontAssetChanged: 0
+  m_subTextObjects:
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &1246550224
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1246550221}
+  m_CullTransparentMesh: 0
+--- !u!1 &1313412110
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1313412111}
+  - component: {fileID: 1313412113}
+  - component: {fileID: 1313412112}
+  m_Layer: 5
+  m_Name: Text (TMP)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1313412111
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1313412110}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1838958203}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: -2, y: -2}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1313412112
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1313412110}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: Properties
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontColor: {r: 1, g: 1, b: 1, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_outlineColor:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontSize: 4
+  m_fontSizeBase: 4
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_textAlignment: 514
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_firstOverflowCharacterIndex: 0
+  m_linkedTextComponent: {fileID: 0}
+  m_isLinkedTextComponent: 0
+  m_isTextTruncated: 0
+  m_enableKerning: 1
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_ignoreRectMaskCulling: 0
+  m_ignoreCulling: 1
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_VertexBufferAutoSizeReduction: 1
+  m_firstVisibleCharacter: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_textInfo:
+    textComponent: {fileID: 1313412112}
+    characterCount: 10
+    spriteCount: 0
+    spaceCount: 0
+    wordCount: 1
+    linkCount: 0
+    lineCount: 1
+    pageCount: 1
+    materialCount: 1
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_spriteAnimator: {fileID: 0}
+  m_hasFontAssetChanged: 0
+  m_subTextObjects:
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &1313412113
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1313412110}
+  m_CullTransparentMesh: 0
+--- !u!1 &1386884731
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1386884732}
+  - component: {fileID: 1386884734}
+  - component: {fileID: 1386884733}
+  m_Layer: 5
+  m_Name: Fill
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1386884732
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386884731}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1673013562}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 10, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1386884733
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386884731}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &1386884734
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386884731}
+  m_CullTransparentMesh: 0
+--- !u!1 &1395040732
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1395040733}
+  - component: {fileID: 1395040734}
+  m_Layer: 5
+  m_Name: Text Area
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1395040733
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1395040732}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1246550222}
+  - {fileID: 1679846698}
+  m_Father: {fileID: 386035}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: -2, y: -2}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1395040734
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1395040732}
   m_Enabled: 1
-  serializedVersion: 3
-  m_RenderMode: 0
-  m_Camera: {fileID: 1399202792}
-  m_PlaneDistance: 100
-  m_PixelPerfect: 0
-  m_ReceivesEvents: 1
-  m_OverrideSorting: 0
-  m_OverridePixelPerfect: 0
-  m_SortingBucketNormalizedSize: 0
-  m_AdditionalShaderChannelsFlag: 25
-  m_SortingLayerID: 0
-  m_SortingOrder: 10
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 3312d7739989d2b4e91e6319e9a96d76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!1 &1399202790
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1399202793}
+  - component: {fileID: 1399202792}
+  - component: {fileID: 1399202791}
+  - component: {fileID: 1399202794}
+  m_Layer: 0
+  m_Name: Camera
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1399202791
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1399202790}
+  m_Enabled: 1
+--- !u!20 &1399202792
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1399202790}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
   m_TargetDisplay: 0
---- !u!224 &707330897
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1399202793
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1399202790}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 8.427671, y: 0, z: 90}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &1399202794
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1399202790}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a79441f348de89743a2939f4d699eac1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_RenderShadows: 1
+  m_RequiresDepthTextureOption: 2
+  m_RequiresOpaqueTextureOption: 2
+  m_CameraType: 0
+  m_CameraOutput: 0
+  m_Cameras: []
+  m_RendererIndex: -1
+  m_VolumeLayerMask:
+    serializedVersion: 2
+    m_Bits: 1
+  m_VolumeTrigger: {fileID: 0}
+  m_RenderPostProcessing: 0
+  m_Antialiasing: 0
+  m_AntialiasingQuality: 2
+  m_StopNaN: 0
+  m_Dithering: 0
+  m_RequiresDepthTexture: 0
+  m_RequiresColorTexture: 0
+  m_Version: 2
+--- !u!1 &1559862515
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1559862516}
+  m_Layer: 5
+  m_Name: TestProperty (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1559862516
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1559862515}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 249243415}
+  - {fileID: 1743066982}
+  m_Father: {fileID: 1109214825}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: -0.000011444092, y: -16}
+  m_SizeDelta: {x: 0, y: 10}
+  m_Pivot: {x: 0.5, y: 1}
+--- !u!1 &1673013561
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1673013562}
+  m_Layer: 5
+  m_Name: Fill Area
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1673013562
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1673013561}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1386884732}
+  m_Father: {fileID: 1743066982}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.35}
+  m_AnchorMax: {x: 1, y: 0.65}
+  m_AnchoredPosition: {x: -5, y: 0}
+  m_SizeDelta: {x: -20, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!1 &1679846697
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1679846698}
+  - component: {fileID: 1679846700}
+  - component: {fileID: 1679846699}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1679846698
 RectTransform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 0, y: 0, z: 0}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 3
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 0, y: 0}
-  m_Pivot: {x: 0, y: 0}
---- !u!114 &707330898
+  m_GameObject: {fileID: 1679846697}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1395040733}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1679846699
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1679846697}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: "\u200B"
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4281479730
+  m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_outlineColor:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontSize: 4
+  m_fontSizeBase: 4
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_textAlignment: 513
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 0
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_firstOverflowCharacterIndex: -1
+  m_linkedTextComponent: {fileID: 0}
+  m_isLinkedTextComponent: 0
+  m_isTextTruncated: 0
+  m_enableKerning: 1
+  m_enableExtraPadding: 1
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_ignoreRectMaskCulling: 0
+  m_ignoreCulling: 1
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_VertexBufferAutoSizeReduction: 1
+  m_firstVisibleCharacter: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_textInfo:
+    textComponent: {fileID: 1679846699}
+    characterCount: 1
+    spriteCount: 0
+    spaceCount: 0
+    wordCount: 1
+    linkCount: 0
+    lineCount: 1
+    pageCount: 1
+    materialCount: 1
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_spriteAnimator: {fileID: 0}
+  m_hasFontAssetChanged: 0
+  m_subTextObjects:
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &1679846700
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1679846697}
+  m_CullTransparentMesh: 0
+--- !u!1 &1710081748
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1710081751}
+  - component: {fileID: 1710081750}
+  - component: {fileID: 1710081749}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1710081749
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
+  m_GameObject: {fileID: 1710081748}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 139c5c0e28dc67c40ad0ac4da3e551fc, type: 3}
+  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
---- !u!114 &707330899
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &1710081750
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 707330893}
+  m_GameObject: {fileID: 1710081748}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: ea7d7495833204790ba1d3a8755397f8, type: 3}
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  ConversionMode: 0
---- !u!1 &1399202790
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!4 &1710081751
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1710081748}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1743066981
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -672,82 +2276,88 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 1399202793}
-  - component: {fileID: 1399202792}
-  - component: {fileID: 1399202791}
-  m_Layer: 0
-  m_Name: Camera
+  - component: {fileID: 1743066982}
+  - component: {fileID: 1743066983}
+  m_Layer: 5
+  m_Name: Slider
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!81 &1399202791
-AudioListener:
+--- !u!224 &1743066982
+RectTransform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1399202790}
-  m_Enabled: 1
---- !u!20 &1399202792
-Camera:
+  m_GameObject: {fileID: 1743066981}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 849133207}
+  - {fileID: 1673013562}
+  - {fileID: 740286396}
+  m_Father: {fileID: 1559862516}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0}
+  m_AnchorMax: {x: 0.5, y: 1}
+  m_AnchoredPosition: {x: 30.000011, y: -0.0000038146973}
+  m_SizeDelta: {x: 30, y: 0}
+  m_Pivot: {x: 1, y: 0.5}
+--- !u!114 &1743066983
+MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1399202790}
+  m_GameObject: {fileID: 1743066981}
   m_Enabled: 1
-  serializedVersion: 2
-  m_ClearFlags: 1
-  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
-  m_projectionMatrixMode: 1
-  m_GateFitMode: 2
-  m_FOVAxisMode: 0
-  m_SensorSize: {x: 36, y: 24}
-  m_LensShift: {x: 0, y: 0}
-  m_FocalLength: 50
-  m_NormalizedViewPortRect:
-    serializedVersion: 2
-    x: 0
-    y: 0
-    width: 1
-    height: 1
-  near clip plane: 0.3
-  far clip plane: 1000
-  field of view: 60
-  orthographic: 0
-  orthographic size: 5
-  m_Depth: 0
-  m_CullingMask:
-    serializedVersion: 2
-    m_Bits: 4294967295
-  m_RenderingPath: -1
-  m_TargetTexture: {fileID: 0}
-  m_TargetDisplay: 0
-  m_TargetEye: 3
-  m_HDR: 1
-  m_AllowMSAA: 1
-  m_AllowDynamicResolution: 0
-  m_ForceIntoRT: 0
-  m_OcclusionCulling: 1
-  m_StereoConvergence: 10
-  m_StereoSeparation: 0.022
---- !u!4 &1399202793
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1399202790}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 8.427671, y: 0, z: 90}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 4
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &1407119036
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 67db9e8f0e2ae9c40bc1e2b64352a6b4, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 808257677}
+  m_FillRect: {fileID: 1386884732}
+  m_HandleRect: {fileID: 808257676}
+  m_Direction: 0
+  m_MinValue: 0
+  m_MaxValue: 1
+  m_WholeNumbers: 0
+  m_Value: 0
+  m_OnValueChanged:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!1 &1778246932
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -755,8 +2365,8 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 1407119038}
-  - component: {fileID: 1407119037}
+  - component: {fileID: 1778246934}
+  - component: {fileID: 1778246933}
   m_Layer: 0
   m_Name: MenuBar
   m_TagString: Untagged
@@ -764,13 +2374,13 @@ GameObject:
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!114 &1407119037
+--- !u!114 &1778246933
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1407119036}
+  m_GameObject: {fileID: 1778246932}
   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: 45a335734b1572644a6a5d09d87adc65, type: 3}
@@ -779,14 +2389,19 @@ MonoBehaviour:
   _SceneAsset: {fileID: 102900000, guid: 2e3f0844eb409cb479eb26b95fd2bc39, type: 3}
   _HierarchyColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
   AutoLoadScene: 1
-  m_SubSceneHeader: {fileID: 11400000, guid: a37df8ef40d73744db597c6825aaaa4a, type: 2}
---- !u!4 &1407119038
+  _SceneGUID:
+    Value:
+      x: 1149301730
+      y: 1271465150
+      z: 2606939799
+      w: 2479566325
+--- !u!4 &1778246934
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1407119036}
+  m_GameObject: {fileID: 1778246932}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
@@ -794,7 +2409,7 @@ Transform:
   m_Father: {fileID: 0}
   m_RootOrder: 6
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &1710081748
+--- !u!1 &1838958202
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -802,61 +2417,106 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 1710081751}
-  - component: {fileID: 1710081750}
-  - component: {fileID: 1710081749}
-  m_Layer: 0
-  m_Name: EventSystem
+  - component: {fileID: 1838958203}
+  - component: {fileID: 1838958205}
+  - component: {fileID: 1838958204}
+  m_Layer: 5
+  m_Name: Panel
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!114 &1710081749
-MonoBehaviour:
+--- !u!224 &1838958203
+RectTransform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1710081748}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  m_HorizontalAxis: Horizontal
-  m_VerticalAxis: Vertical
-  m_SubmitButton: Submit
-  m_CancelButton: Cancel
-  m_InputActionsPerSecond: 10
-  m_RepeatDelay: 0.5
-  m_ForceModuleActive: 0
---- !u!114 &1710081750
+  m_GameObject: {fileID: 1838958202}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1313412111}
+  m_Father: {fileID: 1109214825}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: -0.0000076293945, y: 0}
+  m_SizeDelta: {x: 0, y: 6}
+  m_Pivot: {x: 0.5, y: 1}
+--- !u!114 &1838958204
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1710081748}
+  m_GameObject: {fileID: 1838958202}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_FirstSelected: {fileID: 0}
-  m_sendNavigationEvents: 1
-  m_DragThreshold: 10
---- !u!4 &1710081751
-Transform:
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.3207547, g: 0.3207547, b: 0.3207547, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &1838958205
+CanvasRenderer:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1710081748}
+  m_GameObject: {fileID: 1838958202}
+  m_CullTransparentMesh: 0
+--- !u!1 &2045108540
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2045108541}
+  m_Layer: 5
+  m_Name: TestProperty
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &2045108541
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2045108540}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
+  m_Children:
+  - {fileID: 342594874}
+  - {fileID: 386035}
+  m_Father: {fileID: 1109214825}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: -6}
+  m_SizeDelta: {x: 0, y: 10}
+  m_Pivot: {x: 0.5, y: 1}
diff --git a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample/MenuBar.unity b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample/MenuBar.unity
index 9dde123..b2e4c34 100644
--- a/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample/MenuBar.unity
+++ b/com.dotsui.hybrid-samples/DotsUI.Samples/PrefabExample/PrefabExample/MenuBar.unity
@@ -24,9 +24,9 @@ RenderSettings:
   m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
   m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
   m_AmbientIntensity: 1
-  m_AmbientMode: 3
+  m_AmbientMode: 0
   m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
-  m_SkyboxMaterial: {fileID: 0}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
   m_HaloStrength: 0.5
   m_FlareStrength: 1
   m_FlareFadeSpeed: 3
@@ -51,7 +51,7 @@ LightmapSettings:
     m_IndirectOutputScale: 1
     m_AlbedoBoost: 1
     m_EnvironmentLightingMode: 0
-    m_EnableBakedLightmaps: 0
+    m_EnableBakedLightmaps: 1
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
     serializedVersion: 12
@@ -288,7 +288,6 @@ GameObject:
   - component: {fileID: 568543581}
   - component: {fileID: 568543580}
   - component: {fileID: 568543579}
-  - component: {fileID: 568543583}
   m_Layer: 5
   m_Name: MenuBar
   m_TagString: Untagged
@@ -376,19 +375,6 @@ RectTransform:
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0, y: 0}
---- !u!114 &568543583
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 568543578}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: ea7d7495833204790ba1d3a8755397f8, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  ConversionMode: 0
 --- !u!1 &676036602
 GameObject:
   m_ObjectHideFlags: 0
@@ -657,8 +643,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 23.51, y: 0}
+  m_AnchoredPosition: {x: 0, y: -0.48}
+  m_SizeDelta: {x: 21.51, y: -0.94}
   m_Pivot: {x: 0, y: 0.5}
 --- !u!114 &1328907983
 MonoBehaviour:
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Assets/TMPFontAssetConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Assets/TMPFontAssetConversionSystem.cs
index 62b142a..c71f8c8 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Assets/TMPFontAssetConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Assets/TMPFontAssetConversionSystem.cs
@@ -1,5 +1,6 @@
 using DotsUI.Core;
 using TMPro;
+using Unity.Burst;
 using Unity.Entities;
 using UnityEngine;
 
@@ -11,7 +12,7 @@ public class TMPFontAssetConversionSystem : GameObjectConversionSystem
 		protected override void OnUpdate()
 		{
 			Entities.ForEach<TMP_FontAsset>(this.ConvertTMPFontAsset);
-		}
+        }
 
 		private void ConvertTMPFontAsset(TMP_FontAsset tmpFontAsset)
 		{
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/CanvasConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/CanvasConversionSystem.cs
index 8422207..528233f 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/CanvasConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/CanvasConversionSystem.cs
@@ -72,7 +72,7 @@ private void ConvertCanvas(Canvas canvas)
         private void SetUpScreenSpaceOverlay(Canvas canvas, Entity entity)
         {
             DstEntityManager.AddComponentData(entity, new CanvasScreenSpaceOverlay());
-            DstEntityManager.AddComponentData(entity, new CanvasScreenSize
+            DstEntityManager.AddComponentData(entity, new CanvasSize
             {
                 Value = new int2(Screen.width, Screen.height)
             });
@@ -90,7 +90,7 @@ private void SetUpScreenSpaceCamera(Canvas canvas, Entity entity)
             {
                 Target = proxy
             });
-            DstEntityManager.AddComponentData(entity, new CanvasScreenSize
+            DstEntityManager.AddComponentData(entity, new CanvasSize
             {
                 Value = new int2(canvas.worldCamera.pixelWidth, canvas.worldCamera.pixelHeight)
             });
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ButtonConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ButtonConversionSystem.cs
index d11f271..271babe 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ButtonConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ButtonConversionSystem.cs
@@ -9,18 +9,12 @@
 namespace DotsUI.Hybrid
 {
     [UpdateInGroup(typeof(GameObjectConversionGroup))]
-    class ButtonConversionSystem : SelectableConversionSystem
+    class ButtonConversionSystem : SelectableConversionSystem<Button>
     {
-        protected override void OnUpdate()
-        {
-            Entities.ForEach<Button>(ConvertButton);
-        }
-
-        private void ConvertButton(Button button)
+        protected override void ConvertUnityComponent(Button button)
         {
             var entity = GetPrimaryEntity(button);
             DstEntityManager.AddComponent(entity, typeof(Controls.Button));
-            ConvertSelectable(button);
         }
     }
 }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ImageConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ImageConversionSystem.cs
index 0a827b7..0717500 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ImageConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ImageConversionSystem.cs
@@ -22,16 +22,22 @@ protected override void OnUpdate()
         void ConvertImage(Image image)
         {
             var entity = GetPrimaryEntity(image);
-            var sprite = image.sprite ?? DefaultSprite;
+            Sprite sprite = null;
+            if (image.sprite != null)
+                sprite = image.sprite;
+            else
+                sprite = DefaultSprite;
             var assetEntity = GetPrimaryEntity(sprite);
 
+            //Debug.Log($"image.sprite: {image.sprite} DefaultSprite: {DefaultSprite} sprite: {sprite} assetEntity: {assetEntity}");
+
             SpriteImage spriteImage = new SpriteImage
             {
                 Asset = assetEntity
             };
             DstEntityManager.AddComponentData(entity, spriteImage);
-            DstEntityManager.AddBuffer<ControlVertexData>(entity);
-            DstEntityManager.AddBuffer<ControlVertexIndex>(entity);
+            DstEntityManager.AddBuffer<ElementVertexData>(entity);
+            DstEntityManager.AddBuffer<ElementVertexIndex>(entity);
             DstEntityManager.AddComponent(entity, typeof(ElementVertexPointerInMesh));
             DstEntityManager.AddComponentData(entity, new RebuildElementMeshFlag() { Rebuild = true });
             ConvertGraphic(image);
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/InputFieldConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/InputFieldConversionSystem.cs
index f4fef59..6195973 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/InputFieldConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/InputFieldConversionSystem.cs
@@ -5,22 +5,17 @@
 using System.Threading.Tasks;
 using TMPro;
 using Unity.Entities;
+using UnityEngine.UI;
 
 namespace DotsUI.Hybrid
 {
     [UpdateInGroup(typeof(GameObjectConversionGroup))]
-    class InputFieldConversionSystem : SelectableConversionSystem
+    class InputFieldConversionSystem : SelectableConversionSystem<TMP_InputField>
     {
-        protected override void OnUpdate()
-        {
-            Entities.ForEach<TMP_InputField>(ConvertInputField);
-        }
-
-        private void ConvertInputField(TMP_InputField inputField)
+        protected override void ConvertUnityComponent(TMP_InputField inputField)
         {
             var entity = GetPrimaryEntity(inputField);
             DstEntityManager.AddComponentData(entity, new Input.KeyboardInputReceiver());
-            DstEntityManager.AddBuffer<Input.KeyboardInputBuffer>(entity);
             Entity target = TryGetPrimaryEntity(inputField.textComponent);
             Entity placeholder = TryGetPrimaryEntity(inputField.placeholder);
             DstEntityManager.AddComponentData(entity, new Controls.InputField()
@@ -32,7 +27,6 @@ private void ConvertInputField(TMP_InputField inputField)
             {
                 CaretPosition = 0
             });
-            ConvertSelectable(inputField);
         }
     }
 }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ScrollBarConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ScrollBarConversionSystem.cs
index 515cff1..8c64f79 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ScrollBarConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ScrollBarConversionSystem.cs
@@ -9,14 +9,9 @@
 namespace DotsUI.Hybrid
 {
     [UpdateInGroup(typeof(GameObjectConversionGroup))]
-    class ScrollBarConversionSystem : SelectableConversionSystem
+    class ScrollBarConversionSystem : SelectableConversionSystem<Scrollbar>
     {
-        protected override void OnUpdate()
-        {
-            Entities.ForEach<Scrollbar>(ConvertScrollBar);
-        }
-
-        private void ConvertScrollBar(Scrollbar scrollBar)
+        protected override void ConvertUnityComponent(Scrollbar scrollBar)
         {
             var entity = GetPrimaryEntity(scrollBar);
             var scrollHandle = GetPrimaryEntity(scrollBar.handleRect);
@@ -32,7 +27,6 @@ private void ConvertScrollBar(Scrollbar scrollBar)
             });
             RegisterEventHandler(entity, Input.PointerEventType.BeginDrag | Input.PointerEventType.Drag |
                                          Input.PointerEventType.EndDrag);
-            ConvertSelectable(scrollBar);
         }
     }
 }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SelectableConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SelectableConversionSystem.cs
index 18a4066..b483f84 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SelectableConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SelectableConversionSystem.cs
@@ -10,9 +10,13 @@
 namespace DotsUI.Hybrid
 {
 
-    abstract class SelectableConversionSystem : DotsUIConversionSystem
+    abstract class SelectableConversionSystem<T> : DotsUIConversionSystem where T : Selectable
     {
-        protected void ConvertSelectable(Selectable selectable)
+        protected sealed override void OnUpdate()
+        {
+            Entities.ForEach<T>(ConvertSelectable);
+        }
+        private void ConvertSelectable(T selectable)
         {
             var entity = GetPrimaryEntity(selectable);
             DstEntityManager.AddComponent(entity, typeof(Input.Selectable));
@@ -30,6 +34,10 @@ protected void ConvertSelectable(Selectable selectable)
             });
 
             RegisterEventHandler(entity, Input.PointerEventType.SelectableGroup);
+
+            ConvertUnityComponent(selectable);
         }
+
+        protected abstract void ConvertUnityComponent(T component);
     }
 }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SliderConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SliderConversionSystem.cs
index 3eb908c..38953ab 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SliderConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/SliderConversionSystem.cs
@@ -10,14 +10,9 @@
 namespace DotsUI.Hybrid
 {
     [UpdateInGroup(typeof(GameObjectConversionGroup))]
-    class SliderConversionSystem : SelectableConversionSystem
+    class SliderConversionSystem : SelectableConversionSystem<Slider>
     {
-        protected override void OnUpdate()
-        {
-            Entities.ForEach<Slider>(ConvertSlider);
-        }
-
-        private void ConvertSlider(Slider slider)
+        protected override void ConvertUnityComponent(Slider slider)
         {
             var entity = GetPrimaryEntity(slider);
             DstEntityManager.AddComponentData(entity, new DotsUI.Controls.Slider()
@@ -30,7 +25,6 @@ private void ConvertSlider(Slider slider)
                 SliderDirection = ConvertDirection(slider.direction),
                 WholeNumbers = slider.wholeNumbers
             });
-            ConvertSelectable(slider);
             RegisterEventHandler(entity, PointerEventType.Drag);
         }
 
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/TextConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/TextConversionSystem.cs
index 059bc54..e49301d 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/TextConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/TextConversionSystem.cs
@@ -39,8 +39,8 @@ void ConvertText(TextMeshProUGUI text)
                 fixed (char* textPtr = content)
                     UnsafeUtility.MemCpy(textBuffer.GetUnsafePtr(), textPtr, content.Length * sizeof(char));
             }
-            DstEntityManager.AddBuffer<ControlVertexData>(entity);
-            DstEntityManager.AddBuffer<ControlVertexIndex>(entity);
+            DstEntityManager.AddBuffer<ElementVertexData>(entity);
+            DstEntityManager.AddBuffer<ElementVertexIndex>(entity);
             DstEntityManager.AddComponentData(entity, new RebuildElementMeshFlag() { Rebuild = true });
             ConvertGraphic(text);
         }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs
new file mode 100644
index 0000000..bb84ecd
--- /dev/null
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DotsUI.Input;
+using Unity.Entities;
+using UnityEngine.UI;
+
+namespace DotsUI.Hybrid
+{
+    [UpdateInGroup(typeof(GameObjectConversionGroup))]
+    class ToggleConversionSystem : SelectableConversionSystem<Toggle>
+    {
+        protected override void ConvertUnityComponent(Toggle component)
+        {
+            var entity = GetPrimaryEntity(component);
+            DstEntityManager.AddComponentData(entity,
+                new Controls.Toggle()
+                {
+                    IsOn = component.isOn,
+                    TargetGraphic = component.graphic != null ? GetPrimaryEntity(component.graphic) : Entity.Null,
+                    Group = component.group != null ? GetPrimaryEntity(component.group) : Entity.Null,
+                });
+        }
+    }
+}
\ No newline at end of file
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs.meta b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs.meta
new file mode 100644
index 0000000..df9aca5
--- /dev/null
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/Controls/ToggleConversionSystem.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6641787ea0f263143a122c68bd1f4b39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/RectTransformConversionSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/RectTransformConversionSystem.cs
index 4787ba8..ba2a057 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/RectTransformConversionSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/ConvertToEntity/RectTransformConversionSystem.cs
@@ -41,6 +41,9 @@ private void Convert(RectTransform transform)
             DstEntityManager.RemoveComponent(entity, typeof(Rotation));
             DstEntityManager.RemoveComponent(entity, typeof(NonUniformScale));
 
+            DstEntityManager.RemoveComponent(entity, typeof(LocalToWorld));
+            DstEntityManager.RemoveComponent(entity, typeof(LocalToParent));
+
             if (transform.childCount != 0)
             {
                 var childBuffer = DstEntityManager.AddBuffer<Child>(entity);
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Input/UnityEngineInputHandler.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Input/UnityEngineInputHandler.cs
index fbf2948..5f55882 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Input/UnityEngineInputHandler.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Input/UnityEngineInputHandler.cs
@@ -7,78 +7,82 @@
 namespace DotsUI.Hybrid
 {
     [UpdateInGroup(typeof(InputSystemGroup))]
-    [UpdateBefore(typeof(ControlsInputSystem))]
+    [UpdateBefore(typeof(ControlsInputSystemGroup))]
     class UnityEngineInputHandler : ComponentSystem
     {
         private readonly Event m_Events = new Event();
         private float2 m_LastFrameMousePos;
 
+        private ControlsInputSystem m_ControlsInputSystem;
+
         protected override void OnCreate()
         {
             m_LastFrameMousePos = (Vector2) UnityEngine.Input.mousePosition;
+            m_ControlsInputSystem = World.GetOrCreateSystem<ControlsInputSystem>();
         }
 
         protected override void OnUpdate()
         {
-            var pointerContainerEntity = GetSingletonEntity<NativePointerInputContainer>();
-            var keyboardContainerEntity = GetSingletonEntity<NativeKeyboardInputContainer>();
-
-            var pointerButtonBuffer = EntityManager.GetBuffer<NativePointerButtonEvent>(pointerContainerEntity);
-            var pointerStateBuffer = EntityManager.GetBuffer<NativePointerState>(pointerContainerEntity);
-            var keyboardBuffer = EntityManager.GetBuffer<NativeKeyboardInputEvent>(keyboardContainerEntity);
+            //var pointerContainerEntity = GetSingletonEntity<NativePointerInputContainer>();
+            //var keyboardContainerEntity = GetSingletonEntity<NativeKeyboardInputContainer>();
 
-            int currentPointerOffset = 0;
-            if (UnityEngine.Input.mousePresent)
-            {
-                pointerStateBuffer.ResizeUninitialized(1 + UnityEngine.Input.touchCount);
-                float2 mousePos = (Vector2)UnityEngine.Input.mousePosition;
-                pointerStateBuffer[0] = new NativePointerState()
-                {
-                    PointerId = NativePointerId.Mouse,
-                    Position = mousePos,
-                    Delta = mousePos-m_LastFrameMousePos
-                };
-                m_LastFrameMousePos = mousePos;
-                currentPointerOffset++;
-            }
-            else
-            {
-                pointerStateBuffer.ResizeUninitialized(UnityEngine.Input.touchCount);
-            }
+            //var pointerButtonBuffer = EntityManager.GetBuffer<NativePointerButtonEvent>(pointerContainerEntity);
+            //var pointerStateBuffer = EntityManager.GetBuffer<NativePointerState>(pointerContainerEntity);
+            //var keyboardBuffer = EntityManager.GetBuffer<NativeKeyboardInputEvent>(keyboardContainerEntity);
 
-            for (int i = 0; i < UnityEngine.Input.touchCount; i++)
-            {
-                var touch = UnityEngine.Input.GetTouch(i);
-                pointerStateBuffer[i+currentPointerOffset] = new NativePointerState()
-                {
-                    PointerId = (NativePointerId)(1 + (touch.fingerId)),
-                    Position = touch.position,
-                    Delta = touch.deltaPosition,
-                };
-            }
+            //int currentPointerOffset = 0;
+            //if (UnityEngine.Input.mousePresent)
+            //{
+            //    pointerStateBuffer.ResizeUninitialized(1 + UnityEngine.Input.touchCount);
+            //    float2 mousePos = (Vector2)UnityEngine.Input.mousePosition;
+            //    pointerStateBuffer[0] = new NativePointerState()
+            //    {
+            //        PointerId = NativePointerId.Mouse,
+            //        Position = mousePos,
+            //        Delta = mousePos-m_LastFrameMousePos
+            //    };
+            //    m_LastFrameMousePos = mousePos;
+            //    currentPointerOffset++;
+            //}
+            //else
+            //{
+            //    pointerStateBuffer.ResizeUninitialized(UnityEngine.Input.touchCount);
+            //}
 
+            //for (int i = 0; i < UnityEngine.Input.touchCount; i++)
+            //{
+            //    var touch = UnityEngine.Input.GetTouch(i);
+            //    pointerStateBuffer[i+currentPointerOffset] = new NativePointerState()
+            //    {
+            //        PointerId = (NativePointerId)(1 + (touch.fingerId)),
+            //        Position = touch.position,
+            //        Delta = touch.deltaPosition,
+            //    };
+            //}
 
+            var writer = m_ControlsInputSystem.GetEventWriter();
+            
             for (int i = 0; i < 3; i++)
             {
                 if (UnityEngine.Input.GetMouseButtonDown(i))
-                    pointerButtonBuffer.Add(new NativePointerButtonEvent()
+                    writer.AddPointerEvent(new NativePointerButtonEvent()
                     {
                         EventType = NativeInputEventType.PointerDown,
                         Button = (PointerButton)i
                     });
                 if (UnityEngine.Input.GetMouseButtonUp(i))
-                    pointerButtonBuffer.Add(new NativePointerButtonEvent()
+                    writer.AddPointerEvent(new NativePointerButtonEvent()
                     {
                         EventType = NativeInputEventType.PointerUp,
                         Button = (PointerButton)i
                     });
             }
-            // I had a problem with this loop, so I put this max loop count to avoid deadlocks. I'll investigate this later. Probably misunderstood documentation :)
+            // I had a problem with this loop, so I put this max loop count to avoid deadlocks. I'll investigate this later. Probably misunderstood Event documentation :)
             for (int i = 0; i < 100 && Event.PopEvent(m_Events); i++)
             {
                 if (m_Events.type == EventType.KeyDown)
                 {
-                    keyboardBuffer.Add(new NativeKeyboardInputEvent()
+                    writer.AddKeyboardEvent(new NativeKeyboardInputEvent()
                     {
                         EventType = NativeInputEventType.KeyDown,
                         Character = m_Events.character,
@@ -88,7 +92,7 @@ protected override void OnUpdate()
                 }
                 if (m_Events.type == EventType.KeyUp)
                 {
-                    keyboardBuffer.Add(new NativeKeyboardInputEvent()
+                    writer.AddKeyboardEvent(new NativeKeyboardInputEvent()
                     {
                         EventType = NativeInputEventType.KeyUp,
                         Character = m_Events.character,
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/HybridRenderSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/HybridRenderSystem.cs
index c0c9b0f..93e8555 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/HybridRenderSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/HybridRenderSystem.cs
@@ -199,7 +199,6 @@ private void RebuildMeshAndCommandBuffers()
                         continue;
                     }
 
-                    var entity = chunk.GetNativeArray(entityType)[0];
                     var commandBuffer = chunk.GetSharedComponentData(commandBufferType, EntityManager);
                     var mesh = chunk.GetSharedComponentData(meshType, EntityManager);
                     var vertices = chunk.GetBufferAccessor(vertexBufferType)[0];
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ImguiProxy.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ImguiProxy.cs
index 138ffe3..c33cc94 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ImguiProxy.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ImguiProxy.cs
@@ -15,5 +15,9 @@ void OnGUI()
         }
 
 
+        public static ImguiProxy Create()
+        {
+            return new GameObject("DotsUI_Imgui-proxy").AddComponent<ImguiProxy>();
+        }
     }
 }
\ No newline at end of file
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ScreenSpaceOverlaySystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ScreenSpaceOverlaySystem.cs
index 7779cfa..ea6e8a5 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ScreenSpaceOverlaySystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/ScreenSpaceOverlaySystem.cs
@@ -9,16 +9,14 @@
 namespace DotsUI.Hybrid.Renderer
 {
     [ExecuteAlways]
-    [AlwaysUpdateSystem]
     [UpdateInGroup(typeof(RenderSystemGroup))]
     [UpdateAfter(typeof(HybridRenderSystem))]
     class ScreenSpaceOverlaySystem : JobComponentSystem
     {
         private List<CommandBuffer> m_Buffers = new List<CommandBuffer>();
-        private EntityQuery m_DirtyCanvasQuery;
 
         private ImguiProxy m_Proxy;
-        private EntityQuery m_UnitializedCanvasQuery;
+        private EntityQuery m_UninitializedCanvasQuery;
         private EntityQuery m_ScreenSpaceOverlayQuery;
         private EntityQuery m_DestroyedCanvasQuery;
 
@@ -28,17 +26,7 @@ struct OverlayCanvasInitialized : ISystemStateComponentData
         }
         protected override void OnCreate()
         {
-            m_DirtyCanvasQuery = GetEntityQuery(new EntityQueryDesc()
-            {
-                All = new ComponentType[]
-                {
-                    ComponentType.ReadOnly<CanvasCommandBufferContainer>(),
-                    ComponentType.ReadOnly<CanvasSortLayer>(),
-                    ComponentType.ReadOnly<RebuildCanvasHierarchyFlag>(),
-                    ComponentType.ReadOnly<CanvasScreenSpaceOverlay>(),
-                }
-            });
-            m_UnitializedCanvasQuery = GetEntityQuery(new EntityQueryDesc()
+            m_UninitializedCanvasQuery = GetEntityQuery(new EntityQueryDesc()
             {
                 All = new ComponentType[]
                 {
@@ -73,26 +61,39 @@ protected override void OnCreate()
                 }
             });
 
-            RequireForUpdate(m_UnitializedCanvasQuery);
-            m_Proxy = GameObject.FindObjectOfType<ImguiProxy>();
-            if (m_Proxy == null)
+            RequireForUpdate(m_UninitializedCanvasQuery);
+            InitializeRendererCallbacks();
+        }
+
+        private void InitializeRendererCallbacks()
+        {
+            if (Application.isPlaying)  // We cannot create IMGUI proxy in edit mode
             {
-                m_Proxy = new UnityEngine.GameObject("ScreenSpaceOverlayGUIProxy_DO_NOT_DESTROY").AddComponent<ImguiProxy>();
-                GameObject.DontDestroyOnLoad(m_Proxy.gameObject);
-                m_Proxy.OnRenderGui = OnRenderGui;
+                if (GameObject.FindObjectOfType<ImguiProxy>() == null)
+                {
+                    m_Proxy = ImguiProxy.Create();
+                    m_Proxy.OnRenderGui = OnRenderGui;
+                }
             }
+            RenderPipelineManager.endFrameRendering += OnSrpFinishedRendering;
         }
 
-        protected override void OnDestroy()
+        private void OnSrpFinishedRendering(ScriptableRenderContext srpCtx, Camera[] cameras)
         {
-            m_Buffers.Clear();
-            if (m_Proxy != null)
+            if(m_Proxy != null)
             {
-                if(Application.isPlaying)
-                    GameObject.Destroy(m_Proxy.gameObject);
-                else
-                    GameObject.DestroyImmediate(m_Proxy.gameObject);
+                GameObject.Destroy(m_Proxy.gameObject);
+                m_Proxy = null;
             }
+            OnRenderGui();
+        }
+
+        protected override void OnDestroy()
+        {
+            m_Buffers.Clear();
+            RenderPipelineManager.endFrameRendering -= OnSrpFinishedRendering;
+            if(m_Proxy != null)
+                GameObject.Destroy(m_Proxy.gameObject);
         }
 
         private void OnRenderGui()
@@ -129,7 +130,7 @@ protected override JobHandle OnUpdate(JobHandle inputDeps)
                 }
             }
             layerEntity.Dispose();
-            EntityManager.AddComponent(m_UnitializedCanvasQuery, typeof(OverlayCanvasInitialized));
+            EntityManager.AddComponent(m_UninitializedCanvasQuery, typeof(OverlayCanvasInitialized));
             EntityManager.RemoveComponent(m_DestroyedCanvasQuery, typeof(OverlayCanvasInitialized));
             return inputDeps;
         }
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateCameraSizeSystem.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateCameraSizeSystem.cs
index bb29847..f6cb5e8 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateCameraSizeSystem.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateCameraSizeSystem.cs
@@ -17,7 +17,7 @@ protected override void OnCreate()
                 All = new[]
                 {
                     ComponentType.ReadOnly<CanvasTargetCamera>(),
-                    ComponentType.ReadWrite<CanvasScreenSize>(),
+                    ComponentType.ReadWrite<CanvasSize>(),
                 }
             });
         }
@@ -27,14 +27,14 @@ protected override void OnUpdate()
             using (var chunkArray = m_UpdateSizeGroup.CreateArchetypeChunkArray(Allocator.TempJob))
             {
                 var cameraType = GetArchetypeChunkSharedComponentType<CanvasTargetCamera>();
-                var sizeType = GetArchetypeChunkComponentType<CanvasScreenSize>();
+                var sizeType = GetArchetypeChunkComponentType<CanvasSize>();
                 var entityType = GetArchetypeChunkEntityType();
                 NativeQueue<Entity> commandBuffer = new NativeQueue<Entity>(Allocator.Temp);
                 foreach (var chunk in chunkArray)
                 {
                     var camera = chunk.GetSharedComponentData(cameraType, EntityManager);
 
-                    var canvasSize = new CanvasScreenSize()
+                    var canvasSize = new CanvasSize()
                     {
                         Value = new int2(camera.Target.UnityCamera.pixelWidth, camera.Target.UnityCamera.pixelHeight)
                     };
diff --git a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateScreenSpaceOverlaySize.cs b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateScreenSpaceOverlaySize.cs
index 023d9db..5acc27b 100644
--- a/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateScreenSpaceOverlaySize.cs
+++ b/com.dotsui.hybrid/DotsUI.Hybrid/Renderer/UpdateScreenSpaceOverlaySize.cs
@@ -14,6 +14,7 @@ class UpdateScreenSpaceOverlaySize : ComponentSystem
         private EntityQuery m_UpdateSizeGroup;
         private int m_OldWidth;
         private int m_OldHeight;
+        private EntityQuery m_MissingSize;
 
         protected override void OnCreate()
         {
@@ -25,7 +26,7 @@ protected override void OnCreate()
                 All = new[]
                 {
                     ComponentType.ReadOnly<CanvasScreenSpaceOverlay>(),
-                    ComponentType.ReadWrite<CanvasScreenSize>(),
+                    ComponentType.ReadWrite<CanvasSize>(),
                 }
             });
         }
@@ -34,16 +35,17 @@ protected override void OnUpdate()
         {
             int newWidth = Screen.width;
             int newHeight = Screen.height;
+
             if (m_OldWidth != newWidth || m_OldHeight != newHeight)
             {
                 using (var chunkArray = m_UpdateSizeGroup.CreateArchetypeChunkArray(Allocator.TempJob))
                 {
-                    var sizeType = GetArchetypeChunkComponentType<CanvasScreenSize>();
+                    var sizeType = GetArchetypeChunkComponentType<CanvasSize>();
                     var entityType = GetArchetypeChunkEntityType();
                     NativeQueue<Entity> commandBuffer = new NativeQueue<Entity>(Allocator.Temp);
                     foreach (var chunk in chunkArray)
                     {
-                        var canvasSize = new CanvasScreenSize()
+                        var canvasSize = new CanvasSize()
                         {
                             Value = new int2(newWidth, newHeight)
                         };