Universal Data Browser

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 & Editor

Seamlessly 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<Dictionary<string, Queue<MyStruct>>>) 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 Analytics

Independent 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 Scanner

A 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 Visualizer

Stop 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 Observer

Throw 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 Pipeline

Create 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 Refs

Instantly 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 Tracker

Execute 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 Camera

Track 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 & PROFILING

UDB 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 & SAFETY

Reflection 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<T> or Stack<T>, 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 PRICING

UDB 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.