The ultimate zero-setup memory explorer and workflow enhancer. Effortlessly edit private variables, visualize deeply nested native collections, and track real-time mutations inside your architecture.As a pure C# Reflection engine, UDB is inherently highly compatible. It is an Editor-Only tool that runs in Edit/Play Mode and does not compile into standalone builds. It is Render Pipeline independent. Supported on Windows, macOS, and Linux for Unity 2021.3+.Universal Data Browser (UDB) is a zero-setup runtime memory explorer, deep scanner, and visualizer built specifically to handle complex architectures.Whether you want to quickly tweak a private field, modify deeply nested data inside a massive struct array, or track down a memory leak, UDB allows you to inspect, trace, and manipulate deeply nested data at runtime.No [Attributes], no custom inspectors, no project modifications. Just drag, drop, and dissect your game's memory.⚙️ HOW IT WORKS: 🚀 Fast, Cached & Persistent 🚀One of the biggest frustrations with standard inspectors is losing your place when navigating deeply nested arrays, especially after entering Play Mode or recompiling.To solve this, UDB formats nested memory paths into string-based protocols.To bypass the usual performance overhead of Reflection, UDB dynamically compiles these paths into heavily cached Delegate Fetcher Chains. This guarantees lightning-fast data retrieval.More importantly, because the path is driven by a string protocol, the connection becomes persistent and saveable.You can bookmark any buried variable. UDB's self-healing engine will automatically rebuild the delegate tree and reconnect to your data even after Play Mode toggles or Assembly Reloads.🛠️ CORE MODULES & WORKFLOWS🧠 Unrestricted Browser & EditorSeamlessly browse and edit private fields, internal properties, global static classes and complex collections across your entire runtime memory.UDB offers powerful editing capabilities. You can easily modify values buried inside deeply nested paths (e.g. List>>) at specific indices or inspect entire static managers without needing a live instance in the scene.(Note: Editing Unmanaged Collections is currently unsupported, support is planned).📌 Pinned Watchlist & Continuous AnalyticsIndependent from your main browser, you can "Pin" any variable to a persistent Watchlist.Deep Analytics: Calculates Velocity, Variance, and Zero-Crossings on the fly.Conditional Watchdog: Tell UDB: "If this private health drops below 0, Pause the Unity Editor instantly" so you can inspect the exact frame a bug occurs.Recording & Live Graph: Generates real-time visual graphs and text logs for the pinned data.✨ Custom Data Display & Stylizer (Dynamic Dashboards)Build contextual dashboards instantly. Smartly append external values to any field as metadata.Stylizer: Draw beautiful, custom progress bars or background highlight bars for primitive types based on your own minimum/maximum variable bindings.Indexed Mode: Perfectly aligns bound data with collection indices (e.g., show an entity's name next to its ID in a raw int[] array).Relative Mode: Binds data relative to the instance, fetching values from within the current struct/class automatically.🔍 Scene-Wide Deep ScannerA lifesaver for both casual finding and deep forensics. Scan millions of objects in seconds.Missing References: Locate Missing Scripts or Missing Materials across the hierarchy.Memory Leak Hunter: Find exactly which list is still holding a reference to a Destroyed GameObject (Fake Nulls).Find by Name/Value: Instantly locate a lost GameObject, or find all objects where speed > 50.🪐 Node-Based Scene VisualizerStop cluttering your production scripts with OnDrawGizmos. Route any array of Vector3s, Transforms, or mathematical method returns into a simple node pipeline.It draws customizable spheres, lines, and radars in the Scene View using only the raw memory stream.👁️ Live Deep ObserverThrow an entire object or collection into the Observer, set a depth limit, and watch it work.It continuously scans that specific branch and automatically logs detailed diffs whenever any nested variable changes its state.🔗 Search & Bind PipelineCreate node-based search rules to filter data, or create "Bind Shortcuts" to instantly pull a deeply buried variable right to your screen with one click.🖼️ Visual Asset Gallery & Find RefsInstantly lists every Material, Sprite, Mesh, Scriptable Object, Prefab or any asset reference used by a GameObject and its children.Click "Find Refs" to see exactly which components in the scene are referencing that specific asset.🕵️ Static Code Analyzer (Code Detective)Right-click any variable, and UDB statically analyzes your codebase within Unity.It finds every line of code where your target variable is assigned (=), incremented (++), or called, helping you trace mutations without switching to your IDE.⚡ Advanced Method Invoker & Event TrackerExecute any method directly from the UI without writing test scripts.UDB’s advanced invoker supports passing complex arguments; you can initialize, populate, and pass nested Structs, Classes, or Collections on the fly.It even captures the returned objects, allowing you to deeply inspect the method's output.Furthermore, UDB tracks and exposes active listeners for Delegates/Events instantly.🎥 Virtual Vector Follow CameraTrack data, not just GameObjects. Attach your Scene Camera to track dynamic Vector3 properties directly in memory. Watch AI pathfinding destinations or physics velocity vectors move in real-time, independently of physical objects.💡 RICH METADATA & PROFILINGUDB provides massive amounts of context without you having to dig for it:Auto-Diff Tracing: As you scroll through data, values that change automatically flash with green/red diff highlights in real-time. Live mutation tracking is always active.Comprehensive Metadata: Instantly see a variable's Declared Type, Inherited Base Class, Implemented Interfaces, Attributes, Namespace, Generic Constraints, Enum Format and Access Modifiers (public, internal, unsafe).Instant IDE & Source Comments: One click opens your IDE at that exact line of code. Hover over a field, and UDB dynamically reads your C# comments from the script and displays them as tooltips.Memory Estimation & D.O.D. Profiling: Toggle Cache Line visualization to see the exact byte offset and padding of your structs. Use Deep Memory Estimation to calculate the true, branched RAM footprint of complex class instances.🛡️ FOCUS ON STABILITY & SAFETYReflection tools can be heavy, so I spent a lot of time ensuring UDB doesn't disrupt your workflow.Native Collection Armor: Safely traverses unmanaged memory (NativeArray, NativeHashMap, UnsafeList) with built-in safety checks and Duck-Typed Enumerators to prevent Unity Job System crashes.Zero-GC Virtualization: Renders only visible rows by mathematically calculating layouts, allowing you to scroll through 100,000+ element arrays at 60 FPS without Garbage Collection spikes.Thread-Mutator Protection: Captures safe snapshots of collections and Dictionaries to prevent crashes when they are modified asynchronously by other threads.Custom Collection Shield: Intelligently blocks custom IEnumerable/Count evaluations that might cause unintended side-effects or infinite loops.Global Property Safeguards: Complete control over reflection limits. You can globally block all property evaluations to ensure zero code execution (getters) during inspection, keeping your game state completely untouched.Strictly Non-Invasive Extraction: UDB never resorts to risky raw pointer tracking or memory-chasing to make data explicit, which prevents compatibility issues and memory corruption. It strictly utilizes safe non-destructive Reflection APIs. For instance, when inspecting a Queue or Stack, UDB never executes state-altering operations like Dequeue or Pop. Instead, it reads the internal backing arrays directly or utilizes safe enumerators. Simply put: the pure act of observing your data will never accidentally trigger a write operation or alter your game's runtime state.🔮 ROADMAP & EARLY ADOPTER PRICINGUDB is currently in its Phase 1 rollout. By purchasing now, you secure lifetime access to all future modules. As the tool expands, the price will gradually increase to its final release price.The core architecture for these phases is already live. These aren't built from scratch; they are direct expansions of UDB's robust existing engines.Phase 2 - Dynamic Dashboards & Relational Binding (Coming Next):Built directly upon UDB's currently active Metadata Appender and Pinning engines.Transform any inspected object into a centralized command center. Bind external variables from across your project into a single panel using Relative Pathing and Index-Aware tracking. View and edit related data points side-by-side, perfectly aligned by their collection indices.Phase 3 - UQL, The Conductor & Modding Engine:• Universal Query Language (UQL): A simple, lightweight text-based scripting language. Under the hood, it dynamically compiles into memory layout offsets. By utilizing pure pointer math, it creates a Zero-GC architecture that guarantees ultra-fast execution, 100% IL2CPP compatibility, and total GC-compaction immunity.• The Conductor: The ultimate automation hub. Use it to manage script hooks, orchestrate UQL scenarios, and observe runtime behaviors. You can set up and run continuous background processes to automatically monitor states, catch frame-perfect bugs, and streamline your QA testing.• Standalone Modding: Bring UDB's high-performance layout architecture into compiled game builds. By exposing pre-determined hook points, developers can execute UQL text files at runtime to simulate custom method execution and inject modded content without dealing complex dependencies.(Note: Engine expansions such as GPU-Side Data Exposure and Native Collection Editing will be released steadily alongside these major phases).Thank you for supporting development. Lock in the current price today and let's improve our debugging workflows together.This asset is distributed as precompiled DLL assemblies. Source code is not included.Features:Persistent Reflection Engine: Uses string-based protocols to cache and self-heal deep memory paths.Zero-GC UI Virtualization: Mathematically calculates layouts to render only visible items.Thread-Safe Snapshotting: Safely reads asynchronous or thread-mutated IEnumerables and Dictionaries.Unmanaged Memory Read: Includes built-in IsCreated safety layers for Native collections.Node-Based Visualizer: Converts raw arrays/vectors into Scene View Gizmos (Draws Spheres, Cubes, Lines, and Text).Static Code Analyzer: Built-in Regex/Text parsing to find variable modifications (=, ++, ref/out) across the codebase.Actionable Analytics: Computes real-time Variance, Velocity, and Zero-Crossings for numeric data.Advanced Method Invocation: Execute methods by constructing and passing dynamically initialized Structs, Classes, or Collections as arguments. Deeply inspect the returned complex objects.Event & Delegate Tracking: Expose and monitor listeners for C# Events, Action/Func delegates, and UnityEvent.Unrestricted Editing: Ability to edit almost all non-readonly fields and properties (including private, static, and internal members), 64-bit flag enums, and deeply nested values within generic collections.Configurable Edit Restrictions: Global toggles to independently restrict or allow write-access to specific field categories: Private Fields, Static Fields, Properties, Unity Built-in Properties, Asset Editing, and Edit-Mode execution.Serialization State Indicators: The UI evaluates and displays the persistence outcome of modified variables (Session Only, Persistent, or Asset Editing). Automatically flags unserialized private fields as Session Only during Play Mode.Invoker Consent Locks: Execution of potentially destructive methods (e.g., Dispose()) or sensitive Unity engine functions is internally blocked by default and requires explicit user confirmation before invocation.Non-Mutating Collection Reads: Collection inspection avoids state-altering APIs such as Dequeue(), Pop(), and Remove(). Instead, UDB uses reflection to access the underlying .NET backing structures (such as _array for Queues/Stacks and _entries for HashSets), allowing collections to be inspected without changing their runtime state.In-Place Editing: When editing supported managed collections at runtime, UDB applies in-place updates directly to the underlying storage where possible. Since these edits bypass the standard collection APIs, the collection's internal version counter is not modified. This allows element values to be updated without introducing additional collection state changes that could interfere with active enumeration.Unmanaged Collection Read: For Native structures (e.g., NativeQueue), UDB avoids unsafe memory traversal by utilizing Unity's ToArray() API to generate a temporary NativeArray. After extracting the data safely into the managed realm, UDB automatically invokes unmanaged disposal on the temporary buffer. This guarantees zero unmanaged memory leaks while keeping AtomicSafetyHandle states uncorrupted. UDB uses strategies like this in all its read operations.Supported Data Types for Deep Inspection & Editing:Fields & Value Types: Full inspection and editing support for primitive types, Strings, Enums (including 64-bit Flags), and common Unity types such as Vector2/3/4, int2/3/4, Quaternion, Color, Rect, and Bounds.Standard Collections: Array, List, Dictionary, HashSet, Queue, Stack, Multi-Dimensional Arrays, ArrayList, BitArray, LinkedList, SortedList, SortedDictionary, SortedSet.Unmanaged Collections (Read-Only Inspection): NativeArray, NativeList, NativeHashMap, NativeHashSet, NativeQueue, NativeSlice, NativeBitArray, UnsafeList, UnsafeHashMap, UnsafeHashSet, UnsafeFixedStruct, FixedString, FixedBuffer.(Note: Edit support for Native Collections and Inspection support for NativeMultiHashMap is planned for upcoming updates).Compatibility Information:Editor-Only Tool: UDB operates strictly within the Unity Editor during Edit Mode and Play Mode. It does not compile into standalone builds.Render Pipeline Independent: Works flawlessly across Built-In (BRP), Universal Render Pipeline (URP), and High Definition Render Pipeline (HDRP).OS Support: Fully compatible with Windows, macOS, and Linux Unity Editors.Supported Unity Versions: Tested and supported on Unity 2021.3, 2022.3, 2023.3 (LTS) and Unity 6ECS/DOTS Transparency Note:UDB’s raw reflection engine allows you to inspect many native structures out-of-the-box. However, standard reflection naturally reaches its limits when navigating inside internal memory.To provide true, seamless data inspection for Entities, dedicated wrappers are planned for a future update. This upcoming ECS integration will be developed exclusively for the Unity 6+.AI was used solely as a coding assistant. All core architecture, logic, UI implementation, and final code were designed, implemented, and manually verified by me.
