Frequently asked questions

What is Scriptum exactly, and how is it different from other in-editor consoles?

Scriptum is a live C# scripting console built for Unity. It lets you execute code in real-time without recompilation. Unlike Unity’s default console or other REPL tools, Scriptum supports full Roslyn scripting, REPL and Editor modes, Live Variables, autocomplete, and deep integration with runtime objects. It’s not just for logs — it’s for actual runtime interaction.

Do I need to write full C# classes in Scriptum?

No. In REPL mode, you can just write one-liners or chains of code like @player.health -= 10. But if you want to define reusable logic or classes, you can switch to Editor Mode and write structured C# like you’re in Rider or VSCode. Scriptum supports both use cases.

Can I interact with live GameObjects and Components?

Yes. Scriptum has a system called Live Variables. You can drag a GameObject or Component into the console and it will bind it to a variable like @player. You can then use it anywhere, call methods, check values, change things, all live.

What’s the difference between REPL Mode and Editor Mode?

REPL is for fast execution, you write code and hit Enter. Editor Mode is for writing larger scripts or full classes. Editor Mode supports execution via Run buttons, result panels, and reflection-based inspectors. You can switch anytime.

Is this like Hot Reload?

Not really. Hot Reload patches your compiled assemblies. Scriptum doesn’t touch your compiled code. It runs in a separate context using Roslyn, and it won’t interfere with your original scripts. You can think of it more like a live runtime sandbox.

Can I call methods and access private members?

Yes. You can invoke public, private, and even internal methods using reflection. Scriptum was made for deep inspection and runtime tinkering. That includes accessing private fields, invoking non-public methods, and more.

Is Scriptum safe for runtime use? Will it crash my scene?

Scriptum is powerful — if you execute dangerous code, it’ll do exactly what you asked. But the tool itself wraps evaluation in try-catch blocks, logs errors, and isolates runtime states when possible. You’re in control, but it won’t silently fail.

Can I save and reuse my code?

Yes. Scriptum includes a system for Quick Spells (multiline reusable snippets), Live Spells (template suggestions), and full session saving for Editor scripts. You can build your own toolbox over time.

How does autocomplete work?

Scriptum parses your input using Roslyn, tracks Live Variables, known types, and namespaces, then gives contextual suggestions as you type. This includes @ variable access, class methods, fields, and known symbols.

Can I inspect or debug the result of an evaluated script?

Yes. Any result (object, value, or method return) can be reflected using echo(), manifest(), or directly explored using the Eval Report system. Complex results open in a visual inspector for deeper inspection.

What happens to my scripts after a domain reload or assembly change?

REPL input and Live Variables are session-bound and will be lost on domain reload. Editor Mode scripts can be saved persistently. The system will warn you before anything is lost.

Can I run Scriptum in builds?

No. Scriptum is an Editor-only tool. It relies on reflection and Roslyn scripting, which are not supported in builds. If you're interested in runtime scripting for your game, you’ll need a separate runtime interpreter or embed Scriptum in a stripped-down form manually.

Can Scriptum help me debug Unity code without stopping Play Mode?

Yes. That’s what it was built for. You can log, modify, or inspect anything live without breaking Play Mode. It’s perfect for prototyping, inspecting edge cases, or debugging state without restarting.

Does Scriptum work with DOTS or ECS?

Scriptum was designed for general Unity scripting, but you can inspect and interact with DOTS/ECS data using reflection or custom bindings. Native support is not built-in yet, but planned for future updates.