diff --git a/ResoniteMetricsCounter/Metrics/MetricsCounter.cs b/ResoniteMetricsCounter/Metrics/MetricsCounter.cs
index 1c20b1c..b2ce545 100644
--- a/ResoniteMetricsCounter/Metrics/MetricsCounter.cs
+++ b/ResoniteMetricsCounter/Metrics/MetricsCounter.cs
@@ -1,4 +1,4 @@
-using Elements.Core;
+using Elements.Core;
 using FrooxEngine;
 using FrooxEngine.ProtoFlux;
 using ResoniteMetricsCounter.Serialization;
@@ -61,12 +61,12 @@ private bool ShouldSkipImpl(IWorldElement element)
         }
 
         var slot = element.GetSlotFast();
-        if (slot is null || IgnoredHierarchy is null)
+        if (slot is null)
         {
-            return false;
+            return true;
         }
 
-        return IgnoredHierarchy.IsChildOf(slot, includeSelf: true);
+        return IgnoredHierarchy?.IsChildOf(slot, includeSelf: true) ?? false;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/ResoniteMetricsCounter/Patch/Metric_Profiler_Patch.cs b/ResoniteMetricsCounter/Patch/Metric_Profiler_Patch.cs
index 762f273..aa87eba 100644
--- a/ResoniteMetricsCounter/Patch/Metric_Profiler_Patch.cs
+++ b/ResoniteMetricsCounter/Patch/Metric_Profiler_Patch.cs
@@ -1,4 +1,4 @@
-using FrooxEngine;
+using FrooxEngine;
 using FrooxEngine.ProtoFlux;
 using HarmonyLib;
 using ResoniteModLoader;
diff --git a/ResoniteMetricsCounter/UIX/Item/MetricItemBase.cs b/ResoniteMetricsCounter/UIX/Item/MetricItemBase.cs
deleted file mode 100644
index 04aaccd..0000000
--- a/ResoniteMetricsCounter/UIX/Item/MetricItemBase.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-using Elements.Core;
-using FrooxEngine;
-using FrooxEngine.UIX;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace ResoniteMetricsCounter.UIX.Item;
-
-internal abstract class MetricItemBase<T>
-{
-    private const float DEFAULT_ITEM_SIZE = 32;
-    private const float DEFAULT_PADDING = 4;
-
-    private readonly Slot slot;
-    private readonly Sync<string> labelField, timeField;
-    private readonly Sync<colorX> metricTint;
-    private readonly ReferenceProxySource referenceProxySource;
-    private readonly RectTransform metricRect;
-    private readonly Sync<string> percentageField;
-
-    public MetricItemBase(Slot container)
-    {
-        var uiBuilder = new UIBuilder(container);
-
-        uiBuilder.Style.MinHeight = DEFAULT_ITEM_SIZE;
-        uiBuilder.Style.TextAutoSizeMin = 0;
-
-        slot = uiBuilder.Panel(RadiantUI_Constants.Neutrals.DARK).Slot;
-
-        slot.AttachComponent<Button>();
-        referenceProxySource = slot.AttachComponent<ReferenceProxySource>();
-
-        var metricImage = uiBuilder.Image();
-        metricRect = metricImage.RectTransform;
-        metricTint = metricImage.Tint;
-
-        uiBuilder.HorizontalLayout(DEFAULT_PADDING);
-        uiBuilder.Style.FlexibleWidth = 1.0f;
-
-        var labelText = uiBuilder.Text(null, bestFit: true, alignment: Alignment.MiddleLeft);
-        labelText.RectTransform.AnchorMax.Value = new float2(0.8f, 1.0f);
-        labelText.Color.Value = RadiantUI_Constants.TEXT_COLOR;
-        labelField = labelText.Content;
-
-        uiBuilder.Style.PreferredWidth = uiBuilder.Style.MinWidth = DEFAULT_ITEM_SIZE * 3;
-        uiBuilder.Style.FlexibleWidth = -1.0f;
-        var timeText = uiBuilder.Text(null, bestFit: false, size: 24, alignment: Alignment.MiddleRight);
-        timeText.ParseRichText.Value = false;
-        timeText.Color.Value = RadiantUI_Constants.TEXT_COLOR;
-        timeField = timeText.Content;
-
-        var percentageText = uiBuilder.Text(null, bestFit: false, size: 24, alignment: Alignment.MiddleRight);
-        percentageText.ParseRichText.Value = false;
-        percentageText.Color.Value = RadiantUI_Constants.TEXT_COLOR;
-        percentageField = percentageText.Content;
-
-        uiBuilder.Style.PreferredWidth = uiBuilder.Style.MinWidth = DEFAULT_ITEM_SIZE;
-
-        var deactivateButton = uiBuilder.Button(OfficialAssets.Common.Icons.Cross, RadiantUI_Constants.Hero.RED);
-        deactivateButton.LocalPressed += (_, _) => slot.Destroy();
-    }
-
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract long GetTicks(in T metric);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract string? GetLabel(in T metric);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract IWorldElement? GetReference(in T metric);
-
-    public bool Update(in T metric, long maxTicks, long elapsedTicks)
-    {
-        if (slot.IsDisposed)
-        {
-            return false;
-        }
-
-        var ticks = GetTicks(metric);
-        var maxRatio = (float)ticks / maxTicks;
-
-        slot.OrderOffset = -ticks;
-        var label = GetLabel(metric);
-        if (label is null)
-        {
-            return false;
-        }
-
-        labelField.Value = label;
-
-        var doubleTicks = (double)ticks;
-        timeField.Value = $"{1000.0 * doubleTicks / Stopwatch.Frequency:0.0}ms";
-        percentageField.Value = $"{doubleTicks / elapsedTicks:P3}";
-        metricTint.Value = MathX.Lerp(RadiantUI_Constants.DarkLight.GREEN, RadiantUI_Constants.DarkLight.RED, maxRatio);
-        metricRect.AnchorMax.Value = new float2(maxRatio, 1.0f);
-
-        var reference = GetReference(metric);
-        if (reference is null || reference.IsRemoved)
-        {
-            referenceProxySource.Enabled = false;
-        }
-        else
-        {
-            referenceProxySource.Reference.Target = reference;
-        }
-
-        return true;
-    }
-}
diff --git a/ResoniteMetricsCounter/UIX/Item/MetricPageItemBase.cs b/ResoniteMetricsCounter/UIX/Item/MetricPageItemBase.cs
new file mode 100644
index 0000000..d8d8529
--- /dev/null
+++ b/ResoniteMetricsCounter/UIX/Item/MetricPageItemBase.cs
@@ -0,0 +1,83 @@
+using Elements.Core;
+using FrooxEngine;
+using FrooxEngine.UIX;
+using ResoniteMetricsCounter.Utils;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace ResoniteMetricsCounter.UIX.Item;
+
+
+internal abstract class MetricPageItemBase<T>
+{
+
+    private readonly Slot slot;
+    private readonly Sync<colorX> metricTint;
+    private readonly ReferenceProxySource referenceProxySource;
+    private readonly RectTransform metricRect;
+
+    protected readonly List<Sync<string>> LabelFields = new();
+
+    public MetricPageItemBase(Slot container, List<MetricColumnDefinition> columns)
+    {
+        var uiBuilder = new UIBuilder(container);
+
+        uiBuilder.Style.MinHeight = Constants.ROWHEIGHT;
+        slot = uiBuilder.Panel(RadiantUI_Constants.Neutrals.DARK).Slot;
+
+        slot.AttachComponent<Button>();
+        referenceProxySource = slot.AttachComponent<ReferenceProxySource>();
+
+        var metricImage = uiBuilder.Image();
+        metricRect = metricImage.RectTransform;
+        metricTint = metricImage.Tint;
+
+        LabelFields.Capacity = columns.Count;
+        foreach (var label in MetricColumnDefinition.Build(uiBuilder, columns))
+        {
+            LabelFields.Add(label.Content);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected abstract long GetTicks(in T metric);
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected abstract IWorldElement? GetReference(in T metric);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected abstract void UpdateColumn(in T metric, Sync<string> column, int i, long maxTicks, long elapsedTicks, long frameCount);
+
+    public bool Update(in T metric, long maxTicks, long elapsedTicks, long frameCount)
+    {
+        if (slot.IsDisposed)
+        {
+            return false;
+        }
+
+        var ticks = GetTicks(metric);
+        var maxRatio = (float)ticks / maxTicks;
+        slot.OrderOffset = -ticks;
+
+        for (int i = 0; i < LabelFields.Count; i++)
+        {
+            UpdateColumn(metric, LabelFields[i], i, maxTicks, elapsedTicks, frameCount);
+        }
+
+        metricTint.Value = MathX.Lerp(RadiantUI_Constants.DarkLight.GREEN, RadiantUI_Constants.DarkLight.RED, MathX.Sqrt(maxRatio));
+        metricRect.AnchorMax.Value = new float2(maxRatio, 1.0f);
+
+        var reference = GetReference(metric);
+        if (reference is null || reference.IsRemoved)
+        {
+            referenceProxySource.Enabled = false;
+        }
+        else
+        {
+            referenceProxySource.Reference.Target = reference;
+        }
+
+        return true;
+    }
+}
diff --git a/ResoniteMetricsCounter/UIX/MetricColumnDefinition.cs b/ResoniteMetricsCounter/UIX/MetricColumnDefinition.cs
new file mode 100644
index 0000000..97ed5f5
--- /dev/null
+++ b/ResoniteMetricsCounter/UIX/MetricColumnDefinition.cs
@@ -0,0 +1,51 @@
+using Elements.Core;
+using FrooxEngine;
+using FrooxEngine.UIX;
+using ResoniteMetricsCounter.Utils;
+using System;
+using System.Collections.Generic;
+
+namespace ResoniteMetricsCounter.UIX;
+internal struct MetricColumnDefinition
+{
+    public string Label;
+    public float FlexWidth;
+    public float MinWidth;
+    public Alignment Alignment;
+
+    public MetricColumnDefinition(string label, Alignment alignment = Alignment.MiddleLeft, float flexWidth = -1, float minWidth = -1)
+    {
+        Label = label;
+        FlexWidth = flexWidth;
+        MinWidth = minWidth;
+        Alignment = alignment;
+    }
+
+    public static IEnumerable<Text> Build(UIBuilder uiBuilder, IEnumerable<MetricColumnDefinition> columns, Action<HorizontalLayout>? containerModifier = null)
+    {
+        uiBuilder.PushStyle();
+
+        uiBuilder.Style.MinHeight = Constants.ROWHEIGHT;
+        uiBuilder.Style.TextColor = RadiantUI_Constants.TEXT_COLOR;
+        uiBuilder.Style.TextAlignment = Alignment.MiddleCenter;
+        uiBuilder.Style.ForceExpandWidth = false;
+
+        var horizontalLayout = uiBuilder.HorizontalLayout(Constants.SPACING, Constants.PADDING);
+        if (containerModifier != null)
+        {
+            containerModifier(horizontalLayout);
+        }
+
+        foreach (var column in columns)
+        {
+            uiBuilder.Style.FlexibleWidth = column.FlexWidth;
+            uiBuilder.Style.MinWidth = column.MinWidth;
+            uiBuilder.Panel();
+            yield return uiBuilder.Text(column.Label);
+            uiBuilder.NestOut();
+        }
+        uiBuilder.NestOut();
+
+        uiBuilder.PopStyle();
+    }
+}
diff --git a/ResoniteMetricsCounter/UIX/MetricsPanel.cs b/ResoniteMetricsCounter/UIX/MetricsPanel.cs
index 5012bc5..35aa3b4 100644
--- a/ResoniteMetricsCounter/UIX/MetricsPanel.cs
+++ b/ResoniteMetricsCounter/UIX/MetricsPanel.cs
@@ -1,4 +1,4 @@
-using Elements.Core;
+using Elements.Core;
 using FrooxEngine;
 using FrooxEngine.UIX;
 using ResoniteMetricsCounter.Metrics;
@@ -10,23 +10,32 @@
 namespace ResoniteMetricsCounter.UIX;
 public sealed class MetricsPanel
 {
-
-    private readonly List<KeyValuePair<string, IMetricsPage>> pages = new()
+    private readonly List<KeyValuePair<string, MetricsPageBase>> pages = new()
     {
-        new("Detailed", new DetailedMetricsPanelPage()),
-        new("ObjectRoot", new ObjectRootPage()),
+        new("Detailed", new DetailedPage()),
+        new("Hierarchy", new HierarchyPage()),
     };
 
     public const float DEFAULTITEMSIZE = 32;
     public const float PADDING = 4;
+    public const float DEFAULTSEPARATION = 0.1f;
 
     private readonly MetricsCounter metricsCounter;
     private readonly Slot slot;
-    private readonly Sync<string> statisticsField;
     private readonly int maxItems;
     private readonly Slot? pagesButtonContainer;
     private readonly Slot? pagesContainer;
 
+    private Sync<string>? framesField;
+    private Sync<string>? elapsedTimeField;
+    private Sync<string>? totalTimeField;
+    private Sync<string>? maxTimeField;
+    private Sync<string>? countField;
+    private Sync<string>? frameIntervalField;
+    private Sync<string>? avgTotalTimeField;
+    private Sync<string>? avgMaxTimeField;
+    private Sync<string>? fpsField;
+
     public MetricsPanel(Slot slot, MetricsCounter metricsCounter, in float2 size, int maxItems)
     {
         if (slot is null)
@@ -46,10 +55,16 @@ public MetricsPanel(Slot slot, MetricsCounter metricsCounter, in float2 size, in
         this.slot = uiBuilder.Root;
         metricsCounter.IgnoreHierarchy(slot);
 
+        uiBuilder.Style.MinHeight = DEFAULTITEMSIZE;
+        uiBuilder.Style.ForceExpandHeight = false;
+        uiBuilder.Style.TextColor = RadiantUI_Constants.TEXT_COLOR;
+        uiBuilder.Style.TextAutoSizeMin = 0;
+        uiBuilder.Style.TextAutoSizeMax = 24;
+
         uiBuilder.VerticalLayout(PADDING, forceExpandHeight: false);
 
         BuildStopButtonUI(uiBuilder);
-        statisticsField = BuildStatisticsUI(uiBuilder);
+        BuildHeaderUI(uiBuilder);
 
         var activePage = pages[0].Key;
         pagesButtonContainer = uiBuilder.HorizontalLayout(PADDING).Slot;
@@ -84,9 +99,6 @@ private static UIBuilder CreatePanel(in Slot slot, in float2 size)
         slot.LocalScale = float3.One * 0.00075f;
 
         var uiBuilder = RadiantUI_Panel.SetupPanel(slot, "Metrics", size, pinButton: true);
-        uiBuilder.Style.TextAutoSizeMin = 0;
-        uiBuilder.Style.MinHeight = DEFAULTITEMSIZE;
-        uiBuilder.Style.ForceExpandHeight = false;
 
         return uiBuilder;
     }
@@ -105,12 +117,84 @@ private void BuildStopButtonUI(in UIBuilder uiBuilder)
         };
     }
 
-    private static Sync<string> BuildStatisticsUI(in UIBuilder uiBuilder)
+    private void BuildHeaderUI(UIBuilder uiBuilder)
     {
-        var statisticsText = uiBuilder.Text("Profiling", bestFit: true, alignment: Alignment.MiddleLeft);
-        statisticsText.Color.Value = RadiantUI_Constants.TEXT_COLOR;
-        statisticsText.Size.Value = 24;
-        return statisticsText.Content;
+        uiBuilder.PushStyle();
+        uiBuilder.Style.TextAlignment = Alignment.MiddleLeft;
+
+        const float spacing = 0.25f;
+
+        uiBuilder.HorizontalLayout();
+        uiBuilder.HorizontalElementWithLabel("Frames:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0");
+            framesField = text.Content;
+            return text;
+        });
+        uiBuilder.HorizontalElementWithLabel("Avg:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00FPS");
+            fpsField = text.Content;
+            return text;
+        });
+        uiBuilder.NestOut();
+
+        uiBuilder.HorizontalLayout();
+        uiBuilder.HorizontalElementWithLabel("Elapsed:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            elapsedTimeField = text.Content;
+            return text;
+        });
+        uiBuilder.HorizontalElementWithLabel("Avg:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            frameIntervalField = text.Content;
+            return text;
+        });
+        uiBuilder.NestOut();
+
+        uiBuilder.HorizontalLayout();
+        uiBuilder.HorizontalElementWithLabel("Sum:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            totalTimeField = text.Content;
+            return text;
+        });
+        uiBuilder.HorizontalElementWithLabel("Avg:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            avgTotalTimeField = text.Content;
+            return text;
+        });
+        uiBuilder.NestOut();
+
+        uiBuilder.HorizontalLayout();
+        uiBuilder.HorizontalElementWithLabel("Max:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            maxTimeField = text.Content;
+            return text;
+        });
+        uiBuilder.HorizontalElementWithLabel("Avg:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0.00ms");
+            avgMaxTimeField = text.Content;
+            return text;
+        });
+        uiBuilder.NestOut();
+
+        uiBuilder.HorizontalLayout();
+        uiBuilder.HorizontalElementWithLabel("Count:", spacing, () =>
+        {
+            var text = uiBuilder.Text("0");
+            countField = text.Content;
+            return text;
+        });
+        uiBuilder.Spacer(0.5f);
+        uiBuilder.NestOut();
+
+        uiBuilder.PopStyle();
     }
 
     private void BuildPageButtonUI(in UIBuilder uiBuilder, string label, bool defaultActive)
@@ -147,7 +231,7 @@ private void BuildPageButtonUI(in UIBuilder uiBuilder, string label, bool defaul
         };
     }
 
-    private static void BuildPageUI(UIBuilder uiBuilder, in IMetricsPage page, in string label, bool active)
+    private static void BuildPageUI(UIBuilder uiBuilder, in MetricsPageBase page, in string label, bool active)
     {
         var slot = uiBuilder.Next(label);
         slot.ActiveSelf = active;
@@ -171,12 +255,62 @@ public void Update()
             return;
         }
 
-        if (statisticsField.IsDisposed)
+        metricsCounter.OnUpdate();
+
+        var frames = metricsCounter.FrameCount;
+
+        if (framesField is not null && !framesField.IsDisposed)
         {
-            return;
+            framesField.Value = $"{frames}";
+        }
+
+        var elapsedTime = metricsCounter.ElapsedMilliseconds;
+
+        if (fpsField is not null && !fpsField.IsDisposed)
+        {
+            fpsField.Value = $"{1000 * frames / elapsedTime:0.0}FPS";
+        }
+
+        if (elapsedTimeField is not null && !elapsedTimeField.IsDisposed)
+        {
+            elapsedTimeField.Value = $"{elapsedTime}ms";
+        }
+
+        if (frameIntervalField is not null && !frameIntervalField.IsDisposed)
+        {
+            frameIntervalField.Value = $"{elapsedTime / frames}ms";
         }
 
-        statisticsField.Value = $"Elapsed:\t{metricsCounter.ElapsedMilliseconds:0.00}ms<br>Total:\t{1000.0 * metricsCounter.ByElement.Total / Stopwatch.Frequency:0.00}ms<br>Max:\t{1000.0 * metricsCounter.ByElement.Max / Stopwatch.Frequency:0.00}ms<br>Entities:\t{metricsCounter.ByElement.Count}";
+        var totalTime = 1000.0 * metricsCounter.ByElement.Total / Stopwatch.Frequency;
+
+        if (totalTimeField is not null && !totalTimeField.IsDisposed)
+        {
+            totalTimeField.Value = $"{totalTime:0.00}ms";
+        }
+
+        if (avgTotalTimeField is not null && !avgTotalTimeField.IsDisposed)
+        {
+            avgTotalTimeField.Value = $"{totalTime / frames:0.00}ms";
+        }
+
+
+        var maxTime = 1000.0 * metricsCounter.ByElement.Max / Stopwatch.Frequency;
+
+        if (avgMaxTimeField is not null && !avgMaxTimeField.IsDisposed)
+        {
+            avgMaxTimeField.Value = $"{maxTime / frames:0.00}ms";
+        }
+
+        if (maxTimeField is not null && !maxTimeField.IsDisposed)
+        {
+            maxTimeField.Value = $"{maxTime:0.00}ms";
+        }
+
+
+        if (countField is not null && !countField.IsDisposed)
+        {
+            countField.Value = $"{metricsCounter.ByElement.Count}";
+        }
 
         foreach (var page in pages)
         {
diff --git a/ResoniteMetricsCounter/UIX/Pages/DetailedMetricsPanelPage.cs b/ResoniteMetricsCounter/UIX/Pages/DetailedMetricsPanelPage.cs
deleted file mode 100644
index c947d52..0000000
--- a/ResoniteMetricsCounter/UIX/Pages/DetailedMetricsPanelPage.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-using FrooxEngine;
-using FrooxEngine.UIX;
-using ResoniteMetricsCounter.Metrics;
-using ResoniteMetricsCounter.UIX.Item;
-using ResoniteMetricsCounter.Utils;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ResoniteMetricsCounter.UIX.Pages;
-
-internal sealed class DetailedMetricsPanelPage : IMetricsPage
-{
-    private sealed class LabelValueCache : CachedValueBase<StageMetric<IWorldElement>, int, string>
-    {
-        protected override int GetKey(in StageMetric<IWorldElement> metric)
-        {
-            return metric.Stage.GetHashCode() ^ metric.Target.ReferenceID.GetHashCode();
-        }
-
-        protected override string GetValue(in StageMetric<IWorldElement> metric)
-        {
-            var target = metric.Target;
-            var slot = target.GetSlotFast();
-            var parent = slot?.Parent;
-            var objectRoot = slot?.GetMetricObjectRoot() ?? target.World.RootSlot;
-
-            if (parent is null)
-            {
-                return $"{objectRoot.GetNameFast()}/../{slot?.GetNameFast()}.{target?.GetNameFast()} [{metric.Stage}]";
-            }
-
-            if (slot == objectRoot)
-            {
-                return $"{objectRoot.GetNameFast()} {parent.GetNameFast()}/{slot?.GetNameFast()}.{target?.GetNameFast()} [{metric.Stage}]";
-            }
-
-            if (parent == objectRoot)
-            {
-                return $"{objectRoot.GetNameFast()}/{slot?.GetNameFast()}.{target?.GetNameFast()} [{metric.Stage}]";
-            }
-            return $"{objectRoot.GetNameFast()}/../{parent.GetNameFast()}/{slot?.GetNameFast()}.{target?.GetNameFast()} [{metric.Stage}]";
-        }
-    }
-
-    private readonly LabelValueCache labelCache = new();
-
-    private sealed class Item : MetricItemBase<StageMetric<IWorldElement>>
-    {
-        private readonly LabelValueCache labelCache;
-
-        public Item(Slot container, LabelValueCache labelValueCache) : base(container)
-        {
-            labelCache = labelValueCache;
-        }
-
-        protected override string GetLabel(in StageMetric<IWorldElement> metric)
-        {
-            return labelCache.GetOrCache(metric);
-        }
-
-        protected override IWorldElement? GetReference(in StageMetric<IWorldElement> metric)
-        {
-            return metric.Target.GetSlotFast();
-        }
-
-        protected override long GetTicks(in StageMetric<IWorldElement> metric)
-        {
-            return metric.Ticks;
-        }
-    }
-
-    private Slot? container;
-    private List<Item?>? items;
-
-    public bool IsActive()
-    {
-        return container?.IsActive ?? false;
-    }
-
-    public void BuildUI(UIBuilder uiBuilder)
-    {
-        container = uiBuilder.VerticalLayout(spacing: 8).Slot;
-    }
-
-    public void Update(in MetricsCounter metricsCounter, int maxItems)
-    {
-        if (container is null || container.IsDisposed)
-        {
-            return;
-        }
-
-        var maxTicks = metricsCounter.ByElement.Max;
-        var elapsedTicks = metricsCounter.ElapsedTicks;
-
-        if (items?.Count != maxItems)
-        {
-            if (items is null)
-            {
-                items = new(Enumerable.Repeat<Item?>(null, maxItems));
-            }
-            else
-            {
-                items.AddRange(Enumerable.Repeat<Item?>(null, maxItems - items.Count));
-            }
-        }
-
-        var i = 0;
-        foreach (var metric in metricsCounter.ByElement.Metrics.OrderByDescending(m => m.Ticks).Take(maxItems))
-        {
-            var item = items[i] ?? (items[i] = new Item(container!, labelCache));
-
-            if (!item.Update(metric, maxTicks, elapsedTicks))
-            {
-                metricsCounter.ByElement.Remove(metric.Target);
-            }
-            i++;
-        }
-    }
-
-    public void Dispose()
-    {
-        if (container is not null && !container.IsDisposed)
-        {
-            container.Destroy();
-        }
-    }
-}
diff --git a/ResoniteMetricsCounter/UIX/Pages/DetailedPage.cs b/ResoniteMetricsCounter/UIX/Pages/DetailedPage.cs
new file mode 100644
index 0000000..2931ebe
--- /dev/null
+++ b/ResoniteMetricsCounter/UIX/Pages/DetailedPage.cs
@@ -0,0 +1,103 @@
+using FrooxEngine;
+using ResoniteMetricsCounter.Metrics;
+using ResoniteMetricsCounter.UIX.Item;
+using ResoniteMetricsCounter.Utils;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace ResoniteMetricsCounter.UIX.Pages;
+
+internal sealed class DetailedPage : MetricsPageBase
+{
+    private sealed class Item : MetricPageItemBase<StageMetric<IWorldElement>>
+    {
+        public Item(Slot container, List<MetricColumnDefinition> columns) : base(container, columns)
+        {
+        }
+
+        protected override IWorldElement? GetReference(in StageMetric<IWorldElement> metric)
+        {
+            return metric.Target.GetSlotFast();
+        }
+
+        protected override long GetTicks(in StageMetric<IWorldElement> metric)
+        {
+            return metric.Ticks;
+        }
+        protected override void UpdateColumn(in StageMetric<IWorldElement> metric, Sync<string> column, int i, long maxTicks, long totalTicks, long frameCount)
+        {
+            switch (i)
+            {
+                case 0:
+                    column.Value = metric.Target.GetMetricObjectRoot()?.Name!;
+                    break;
+                case 1:
+                    column.Value = metric.Target.GetSlotFast()?.Parent?.Name!;
+                    break;
+                case 2:
+                    column.Value = metric.Target.GetSlotFast()?.Name!;
+                    break;
+                case 3:
+                    column.Value = metric.Target.Name;
+                    break;
+                case 4:
+                    column.Value = $"{metric.Stage}";
+                    break;
+                case 5:
+                    column.Value = $"{1000.0 * metric.Ticks / Stopwatch.Frequency / frameCount:0.00}ms";
+                    break;
+                case 6:
+                    column.Value = $"{(double)metric.Ticks / totalTicks:0.000%}";
+                    break;
+            }
+        }
+    }
+
+    protected override List<MetricColumnDefinition> Columns => new() {
+            new("Object Root", flexWidth: Constants.FLEX),
+            new("Parent", flexWidth: Constants.FLEX),
+            new("Slot", flexWidth: Constants.FLEX),
+            new("Component", flexWidth: Constants.FLEX),
+            new("Stage", flexWidth: Constants.FLEX),
+            new("Time", minWidth: Constants.FIXEDWIDTH),
+            new("%", minWidth: Constants.FIXEDWIDTH),
+    };
+
+    private List<Item?>? items;
+    public override void Update(in MetricsCounter metricsCounter, int maxItems)
+    {
+        if (container is null || container.IsDisposed)
+        {
+            return;
+        }
+
+        var maxTicks = metricsCounter.ByElement.Max;
+        var totalTicks = metricsCounter.ByElement.Total;
+        var frameCount = metricsCounter.FrameCount;
+
+        if (items?.Count != maxItems)
+        {
+            if (items is null)
+            {
+                items = new(Enumerable.Repeat<Item?>(null, maxItems));
+            }
+            else
+            {
+                items.AddRange(Enumerable.Repeat<Item?>(null, maxItems - items.Count));
+            }
+        }
+
+        var i = 0;
+        foreach (var metric in metricsCounter.ByElement.Metrics.OrderByDescending(m => m.Ticks).Take(maxItems))
+        {
+            var item = items[i] ?? (items[i] = new Item(container, Columns));
+
+            if (!item.Update(metric, maxTicks, totalTicks, frameCount))
+            {
+                metricsCounter.ByElement.Remove(metric.Target);
+            }
+            i++;
+        }
+    }
+}
diff --git a/ResoniteMetricsCounter/UIX/Pages/HierarchyPage.cs b/ResoniteMetricsCounter/UIX/Pages/HierarchyPage.cs
new file mode 100644
index 0000000..1be969c
--- /dev/null
+++ b/ResoniteMetricsCounter/UIX/Pages/HierarchyPage.cs
@@ -0,0 +1,85 @@
+using FrooxEngine;
+using ResoniteMetricsCounter.Metrics;
+using ResoniteMetricsCounter.UIX.Item;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace ResoniteMetricsCounter.UIX.Pages;
+
+internal sealed class HierarchyPage : MetricsPageBase
+{
+    private sealed class Item : MetricPageItemBase<Metric<Slot>>
+    {
+        public Item(Slot container, List<MetricColumnDefinition> columns) : base(container, columns)
+        {
+        }
+
+        protected override IWorldElement? GetReference(in Metric<Slot> metric)
+        {
+            return metric.Target;
+        }
+        protected override long GetTicks(in Metric<Slot> metric)
+        {
+            return metric.Ticks;
+        }
+
+        protected override void UpdateColumn(in Metric<Slot> metric, Sync<string> column, int i, long maxTicks, long totalTicks, long frameCount)
+        {
+            switch (i)
+            {
+                case 0:
+                    column.Value = metric.Target.Name;
+                    break;
+                case 1:
+                    column.Value = $"{1000.0 * metric.Ticks / Stopwatch.Frequency / frameCount:0.00}ms";
+                    break;
+                case 2:
+                    column.Value = $"{(double)metric.Ticks / maxTicks:0.00%}";
+                    break;
+            }
+        }
+    }
+
+    protected override List<MetricColumnDefinition> Columns => new() {
+        new ("Hierarchy", flexWidth: 1.0f),
+        new ("Time", minWidth: 32 * 3),
+        new ("%", minWidth: 32 * 3),
+    };
+
+    private readonly List<Item?> items = new();
+
+    public override void Update(in MetricsCounter metricsCounter, int maxItems)
+    {
+        if (container is null || container.IsDisposed)
+        {
+            return;
+        }
+
+        if (items.Count < maxItems)
+        {
+            items.AddRange(Enumerable.Repeat<Item?>(null, maxItems - items.Count));
+        }
+
+        var maxTicks = metricsCounter.ByObjectRoot.Max;
+        var totalTicks = metricsCounter.ByObjectRoot.Total;
+        var frameCount = metricsCounter.FrameCount;
+
+        int i = 0;
+        foreach (var metric in metricsCounter.ByObjectRoot.Metrics.OrderByDescending(m => m.Ticks).Take(maxItems))
+        {
+            var item = items[i] ??= new Item(container, Columns);
+            if (i == 0)
+            {
+                maxTicks = metric.Ticks;
+            }
+
+            if (!item.Update(metric, maxTicks, totalTicks, frameCount))
+            {
+                metricsCounter.ByObjectRoot.Remove(metric.Target);
+            }
+
+            i++;
+        }
+    }
+}
diff --git a/ResoniteMetricsCounter/UIX/Pages/IMetricsPage.cs b/ResoniteMetricsCounter/UIX/Pages/IMetricsPage.cs
deleted file mode 100644
index db01ecb..0000000
--- a/ResoniteMetricsCounter/UIX/Pages/IMetricsPage.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using FrooxEngine.UIX;
-using ResoniteMetricsCounter.Metrics;
-using System;
-
-namespace ResoniteMetricsCounter.UIX.Pages;
-
-internal interface IMetricsPage : IDisposable
-{
-    bool IsActive();
-    void BuildUI(UIBuilder uiBuilder);
-    void Update(in MetricsCounter metricsCounter, int maxItems);
-}
diff --git a/ResoniteMetricsCounter/UIX/Pages/MetricsPageBase.cs b/ResoniteMetricsCounter/UIX/Pages/MetricsPageBase.cs
new file mode 100644
index 0000000..0ce8130
--- /dev/null
+++ b/ResoniteMetricsCounter/UIX/Pages/MetricsPageBase.cs
@@ -0,0 +1,38 @@
+using FrooxEngine;
+using FrooxEngine.UIX;
+using ResoniteMetricsCounter.Metrics;
+using System;
+using System.Collections.Generic;
+
+namespace ResoniteMetricsCounter.UIX.Pages;
+
+internal abstract class MetricsPageBase : IDisposable
+{
+    protected abstract List<MetricColumnDefinition> Columns { get; }
+
+    public abstract void Update(in MetricsCounter metricsCounter, int maxItems);
+
+    protected Slot? container { get; private set; }
+    public bool IsActive()
+    {
+        return container?.IsActive ?? false;
+    }
+
+    public void BuildUI(UIBuilder uiBuilder)
+    {
+        container = uiBuilder.VerticalLayout(RadiantUI_Constants.GRID_PADDING).Slot;
+        container.Disposing += _ => container = null;
+
+        foreach (var _ in MetricColumnDefinition.Build(uiBuilder, Columns, static c => c.Slot.OrderOffset = long.MinValue))
+        {
+
+        }
+
+        uiBuilder.NestOut();
+    }
+
+    public void Dispose()
+    {
+        container?.Dispose();
+    }
+}
diff --git a/ResoniteMetricsCounter/UIX/Pages/ObjectRootPage.cs b/ResoniteMetricsCounter/UIX/Pages/ObjectRootPage.cs
deleted file mode 100644
index d0f077e..0000000
--- a/ResoniteMetricsCounter/UIX/Pages/ObjectRootPage.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-using FrooxEngine;
-using FrooxEngine.UIX;
-using ResoniteMetricsCounter.Metrics;
-using ResoniteMetricsCounter.UIX.Item;
-using ResoniteMetricsCounter.Utils;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ResoniteMetricsCounter.UIX.Pages;
-
-internal sealed class ObjectRootPage : IMetricsPage
-{
-    private sealed class Item : MetricItemBase<Metric<Slot>>
-    {
-        public Item(Slot container) : base(container)
-        {
-        }
-        protected override string GetLabel(in Metric<Slot> metric)
-        {
-            return $"{metric.Target.GetNameFast()}";
-        }
-        protected override IWorldElement? GetReference(in Metric<Slot> metric)
-        {
-            return metric.Target;
-        }
-        protected override long GetTicks(in Metric<Slot> metric)
-        {
-            return metric.Ticks;
-        }
-    }
-
-    private Slot? container;
-    private readonly List<Item?> items = new();
-
-
-    public void BuildUI(UIBuilder uiBuilder)
-    {
-        container = uiBuilder.VerticalLayout(RadiantUI_Constants.GRID_PADDING).Slot;
-        container.Destroyed += (_) => Dispose();
-    }
-
-    public void Dispose()
-    {
-        if (container is not null && !container.IsDisposed)
-        {
-            container.Destroy();
-        }
-    }
-
-    public bool IsActive()
-    {
-        return container is not null && !container.IsDisposed && container.IsActive;
-    }
-
-    public void Update(in MetricsCounter metricsCounter, int maxItems)
-    {
-        if (container is null || container.IsDisposed)
-        {
-            return;
-        }
-
-        if (items.Count < maxItems)
-        {
-            items.AddRange(Enumerable.Repeat<Item?>(null, maxItems - items.Count));
-        }
-
-        long maxTicks = metricsCounter.ByObjectRoot.Max;
-        var elapsedTicks = metricsCounter.ElapsedTicks;
-
-        int i = 0;
-        foreach (var metric in metricsCounter.ByObjectRoot.Metrics.OrderByDescending(m => m.Ticks).Take(maxItems))
-        {
-            var item = items[i] ??= new Item(container!);
-            if (i == 0)
-            {
-                maxTicks = metric.Ticks;
-            }
-
-            if (!item.Update(metric, maxTicks, elapsedTicks))
-            {
-                metricsCounter.ByObjectRoot.Remove(metric.Target);
-            }
-
-            i++;
-        }
-    }
-}
diff --git a/ResoniteMetricsCounter/Utils/Constants.cs b/ResoniteMetricsCounter/Utils/Constants.cs
new file mode 100644
index 0000000..488694f
--- /dev/null
+++ b/ResoniteMetricsCounter/Utils/Constants.cs
@@ -0,0 +1,11 @@
+namespace ResoniteMetricsCounter.Utils;
+
+internal struct Constants
+{
+    public const float ROWHEIGHT = 32;
+    public const float HEIGHT = 24;
+    public const float FIXEDWIDTH = 32 * 3;
+    public const float PADDING = 4;
+    public const float SPACING = 8;
+    public const float FLEX = 1;
+}