unity-scriptableobjects

Q: How do I install unity-scriptableobjects?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill unity-scriptableobjects in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/unity-scriptableobjects/ (personal) or .claude/skills/unity-scriptableobjects/ (project).

by gamedev-skillsAI & Agents

Architect Unity 6.3 LTS data and decoupling with ScriptableObjects: config/data assets, shared runtime variables, event channels, and runtime sets/registries. Use when designing data-driven systems, replacing singletons/managers, creating .asset data with CreateAssetMenu, or when the user mentions ScriptableObject, SO architecture, or data assets.

Installs: 6K
Last 24h: +312
Trending rank: #935
Security: Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill unity-scriptableobjects

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads unity-scriptableobjects automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·This skill provides standard architectural patterns for Unity game development using ScriptableObjects. No security issues were detected.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

SKILL.md

The instructions your agent reads when the skill is triggered.

Unity ScriptableObject Architecture

Use ScriptableObject assets to store shared data and decouple systems in Unity 6.3 LTS — configuration, event channels, and registries that live as project assets instead of being hard-wired into scenes or singletons. Targets Unity 6.3 LTS (6000.3).

When to use

Use when you need designer-editable config (weapon stats, level data), to share one value between unrelated systems, to decouple senders from listeners via event channels, or to build a runtime registry of active objects — without a static/singleton manager.
Use when the project has *.asset data files backed by : ScriptableObject classes.

When not to use: per-instance runtime state that differs per GameObject (that belongs on a MonoBehaviour) — a ScriptableObject asset is shared by everyone who references it. Saving player progress to disk → save-systems. Plain DTOs that never need to be an asset can just be [System.Serializable] classes.

Core workflow

Define the class deriving from ScriptableObject and tag it with [CreateAssetMenu] so designers can create instances from the Assets menu.
Create one or more .asset instances in the Project window; each is a shared, named piece of data referenced by [SerializeField] fields.
Reference, don't copy. MonoBehaviours hold a reference to the asset; they all see the same data, so changing the asset changes every consumer.
For decoupling, model signals and shared variables as ScriptableObjects: a "FloatVariable" the HUD reads and the player writes; an "event channel" the player raises and many systems listen to. Neither side references the other.
Reset runtime mutations in OnEnable if the asset is mutated during play, because edits made in the Editor at runtime persist on the asset (a frequent source of "my values changed after I played").
Verify by inspecting the asset values during Play mode and confirming consumers react.

Patterns

1. Config/data asset

using UnityEngine;

[CreateAssetMenu(fileName = "WeaponData", menuName = "Game/Weapon Data", order = 0)]
public class WeaponData : ScriptableObject
{
    public string displayName = "Pistol";
    public int    damage = 10;
    public float  fireRate = 0.25f;
    public GameObject projectilePrefab;
}

public class Weapon : MonoBehaviour
{
    [SerializeField] private WeaponData data;   // assign the shared asset in the Inspector
    private void Fire() => Debug.Log($"{data.displayName} for {data.damage}");
}

2. Shared runtime variable (decouples producer from consumer)

[CreateAssetMenu(menuName = "Game/Float Variable")]
public class FloatVariable : ScriptableObject
{
    [SerializeField] private float initialValue;
    [System.NonSerialized] public float runtimeValue;   // not saved to the asset

    private void OnEnable()
    {
        runtimeValue = initialValue;                    // reset when the asset loads
#if UNITY_EDITOR
        // With Reload Domain off, OnEnable does not run again on Play, so also reset there.
        UnityEditor.EditorApplication.playModeStateChanged -= ResetOnPlay;
        UnityEditor.EditorApplication.playModeStateChanged += ResetOnPlay;
#endif
    }

#if UNITY_EDITOR
    private void OnDisable() => UnityEditor.EditorApplication.playModeStateChanged -= ResetOnPlay;

    private void ResetOnPlay(UnityEditor.PlayModeStateChange change)
    {
        if (change == UnityEditor.PlayModeStateChange.ExitingEditMode) runtimeValue = initialValue;
    }
#endif
}
// Player writes playerHealth.runtimeValue; the HUD reads it — neither references the other.

3. Creating an instance at runtime (not an asset on disk)

// For transient SO data you build in code (e.g. a generated config).
var temp = ScriptableObject.CreateInstance<WeaponData>();
temp.damage = 25;
// ...use temp...  Destroy(temp);   // clean up runtime-created instances

Pitfalls

Editing an SO at runtime persists in the Editor — values you change during Play stay changed on the asset after you stop. Keep mutable runtime state in [NonSerialized] fields reset in OnEnable, or it will surprise you. (In a build, asset edits do not persist across launches.)
Disabled Domain Reload skips your OnEnable reset — with Enter Play Mode Options enabled and Reload Domain off (a Unity 6.3 LTS fast-iteration setting), already-loaded SOs are not re-created when you press Play, so OnEnable never fires and runtimeValue keeps its value from the previous session (non-serialized fields keep their Play-mode values). Also reset on EditorApplication.playModeStateChanged (pattern 2), or from a static [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] method.
Expecting per-object state — every reference points to the same asset. If two enemies need different current HP, store HP on the MonoBehaviour, not the shared SO.
No frame lifecycle — ScriptableObjects have OnEnable/OnDisable/OnDestroy but no Update. Don't expect per-frame callbacks.
Using SOs as a save file — they're authoring assets, not runtime persistence; write progress with save-systems instead.
Leaking CreateInstance objects — runtime-created instances are not garbage-collected like plain C# objects; Destroy them when done.

References

For the event-channel pattern (a GameEvent SO + listeners, type-safe payloads) and runtime sets/registries (a shared list of active enemies), read references/event-channels.md.
Primary docs: Unity Manual "ScriptableObject" (/Manual/class-ScriptableObject.html) and "Enter Play mode with domain reload disabled" (/Manual/domain-reloading.html), plus ScriptReference/ScriptableObject, ScriptReference/CreateAssetMenuAttribute.

Related skills

unity-csharp-scripting — the MonoBehaviours that consume these assets.
save-systems — persisting state to disk (what SOs are not for).
card-game / rpg / survival-crafting — genres that lean on SO-driven data.

FAQ

What does the unity-scriptableobjects skill do?

How do I install unity-scriptableobjects?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill unity-scriptableobjects in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/unity-scriptableobjects/ (personal) or .claude/skills/unity-scriptableobjects/ (project).

Which AI agents can use unity-scriptableobjects?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is unity-scriptableobjects safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains unity-scriptableobjects?

It is published by gamedev-skills in gamedev-skills/awesome-gamedev-agent-skills. It has 6,002 recorded installs.