Coming to the Unity Asset Store

The debug panel your build is missing

Cheats and options, a console and a lightweight profiler, in one overlay that runs on the device your bug actually happens on. One line of code per cheat, no scene setup, and one toggle strips all of it out of release builds.

Unity 2022.3 LTS and Unity 6 · Built-in, URP and HDRP · full C# source included

DebugCheats.cs
// Every cheat is one line. No attributes, no partial class, no setup.
DMD.Options.AddToggle("God Mode", () => _god, v => _god = v);

DMD.Options.AddFloat("Spawn Rate", () => _rate, v => _rate = v)
    .WithRange(0f, 10f)
    .WithStep(0.5f)
    .InCategory("Combat");

DMD.Options.AddButton("Give 1,000 Gold", () => Wallet.Add(1000));
Screenshot pending - the panel open on a phone: Options tab with toggles, a slider, a picker row and a pinned FPS widget
The panel on device. The same UI docks into an editor window, unchanged.
What is in the panel

Three tools, one overlay

Options you can drive with a thumb, a console that remembers what happened before your first scene loaded, and a profiler that tells you when the frame went wrong.

Options that stay usable at 200 cheats

Toggles, numbers with ranges and step buttons, text, enums, buttons and read-only info. Organize with tabs and categories, search across the lot, or put related controls side by side on one row.

  • Live by default. Visible widgets re-read your getter several times a second, so a value changed by gameplay updates in the panel.
  • No ownership. The getter and setter can point at a private field, a static, or straight at Time.timeScale.
  • Add and remove at runtime. Scope a set of options to a scene or a live-ops event and let cleanup happen by itself.
Screenshot pending - Options tab with categories, a search field, a stepper row and a side-by-side row

Pick one of ten thousand things

Hand any collection to a picker: inventory items, maps, live-ops events, enums. You supply the list and a display adapter; the panel supplies a virtualized, fuzzy-searchable overlay with an optional icon column, list or grid layout, and single or multi select.

  • 10,000 items without a hitch, because rows are virtualized rather than paged.
  • Providers, not snapshots. Pass a delegate and the picker reflects whatever your game currently has.
Screenshot pending - the picker overlay with a search term typed, icon rows matching, and the grid toggle visible

A console that was already listening

Log capture starts at subsystem registration, so the errors thrown before your first scene loaded are in the buffer waiting for you. Filter by severity, search the text, collapse duplicates, and open any entry for the full message and stack trace with nothing truncated.

  • Smooth at 50,000 entries.
  • An error signal on the trigger corner, so you know something went wrong without opening the panel.
  • Frame time, FPS and memory from the profiler tab, or pinned to a screen corner while you play.
Screenshot pending - the console tab with severity filters and a selected entry showing its stack trace, plus the frame time graph
How it behaves

Built for how builds actually ship

The awkward parts of a debug tool are the ones you meet at the end of the project: stripping, IL2CPP, the build that has to go to the store clean.

Zero scene setup

No prefab to drag, no manager object, no per-pipeline variant. The panel creates itself on startup and defaults apply until you decide otherwise.

IL2CPP-safe by construction

Options bind through the delegates you pass in. There is no reflection to survive managed stripping, so High stripping holds no surprises.

Gone from release builds

One toggle removes every asset and assembly from the build. Your registration calls still compile, and quietly do nothing.

Themeable with one USS file

Six themes ship, from Slate to Phosphor. Your own is a stylesheet dropped in a Resources folder - no prefabs to touch, no package to edit.

Pin anything to the screen

Float an option outside the panel as a mini widget: watch a value or flip a cheat mid-run. Pins dock to a corner and persist on the device.

The same panel, docked in the editor

Open it as an editor window and work from a keyboard. Editor-only utilities can register there too, outside play mode.

Opens the way testers expect

Triple-tap or hold a corner on device, F1 on desktop, or call it from code. Gate it behind a PIN when the build goes to outside testers.

Full source, no black box

Every line ships as readable C# in your project. No DLLs to work around when you need to know what it did.

Migrating

Coming from SRDebugger

An SROptions class converts one line at a time. The mapping is mechanical, nothing has to move house, and both panels can run side by side while you work through it.

Before
public partial class SROptions
{
    [Category("Combat")]
    [DisplayName("Spawn Rate")]
    [NumberRange(0, 10)]
    [Increment(0.5)]
    public float SpawnRate
    {
        get { return _spawnRate; }
        set { _spawnRate = value; OnPropertyChanged("SpawnRate"); }
    }
}
After
DMD.Options.AddFloat("Spawn Rate", () => _spawnRate, v => _spawnRate = v)
    .WithRange(0f, 10f)
    .WithStep(0.5f)
    .InCategory("Combat");

Every attribute becomes a modifier on the same line. The label is data rather than an identifier, so renames cost nothing, and OnPropertyChanged disappears - visible widgets re-read the getter for you.

The attribute-by-attribute mapping →

Compatibility

What it needs

No other packages, no TextMeshPro dependency, nothing to configure per platform.

Unity
2022.3 LTS or newerUnity 6 included
Render pipelines
Built-in, URP, HDRPNo per-pipeline setup
Input
Both input systemsDetected automatically
UI
UI ToolkitThemeable with USS
Scripting backend
Mono and IL2CPPManaged stripping High
Source
Included in fullNo compiled DLLs
Questions

Before you ask

Does it survive IL2CPP with managed stripping set to High?

That is the configuration it is built and tested against. Options bind through delegates you pass in, so there is no reflection for the stripper to break. There is no attribute-based discovery, deliberately: registration is explicit and that is the whole story.

How do I keep it out of the build I ship to players?

You don't have to do anything: release builds leave the runtime code and assets out, and only development builds (or builds that define DEBUGMD_ENABLED) keep them. Your DMD calls stay where they are, compile, and do nothing. See Ship without your cheats.

Do I have to open the panel to see a value change?

No. Widgets poll your getters while they are visible, and options can be added or removed at any time with the panel already open. Pin a value to the screen and you can watch it without opening the panel at all.

Will it work with my UI, my pipeline, my input setup?

The panel renders through UI Toolkit on its own PanelSettings, so it does not join your uGUI canvas hierarchy or care which render pipeline you use. Legacy Input Manager and the new Input System are both supported and detected at compile time.

Can I restyle it to match our tools?

Yes, and without touching the package. A theme is one .uss file dropped into a Resources/DebugMDThemes/ folder in your own project; it then appears in the panel's theme picker. Six themes ship as working references.

Is there a command console or REPL?

No. Debug MD gives you typed widgets and buttons rather than a text command parser. If what you want is a console you type into, a different tool is the better fit.

When does it launch, and what will it cost?

It is in release engineering now and goes to the Unity Asset Store when it is done. Asset Store review takes as long as it takes, so no date is promised here. Mail support@debugmd.dev and you will hear when it lands.

Read it before you buy it

The full documentation is public, including the complete API reference. Fourteen pages, no signup, no sales wall.