Development of Custom Editors for Content Managers in Games
One of our clients — a game designer — wanted to add a new level to a mobile RPG project. Without a custom tool, the process looks like this: he opens Unity Editor, creates a ScriptableObject, fills fields manually, sees no preview, accidentally leaves a null in a mandatory field — and the bug is discovered in QA a week later. That delay — a week to find one null — costs the project time and money. With our Level Editor inside Unity: visual level list, drag-and-drop order, built-in validation, level icon preview right in the tool.
The difference is not just convenience. It's iteration speed and the number of content bugs. Our experience shows that custom editors reduce content creation time by 40–60% and cut release bugs by 5x.
In this article we’ll examine which editor types are in demand in gamedev, how we implement them in Unity and Unreal Engine, and what benefits they bring to the team. If you need a custom tool — contact us for an initial analysis.
What problems do custom editors solve?
Custom Editor Windows for working with game data. Typical cases: quest editor (dependency tree, conditions, rewards), dialogue editor (branching graph), economy editor (price tables, exchange rates, balance), loot editor (probabilities, weights, drop conditions). All of this can be stored in ScriptableObject or JSON — but editing via the standard Inspector is slow and error-prone. Development of such tools takes from 3 days to 4 weeks depending on complexity.
EditorWindow in Unity is the base class for any tool. IMGUI (GUILayout, EditorGUILayout) or the new UI Toolkit (USS + UXML) — we choose based on the task. UI Toolkit is preferable for complex interfaces with trees, lists, drag-and-drop. IMGUI is faster for simple forms and doesn't require separate markup files.
PropertyDrawer and CustomEditor — when you don't need a separate window but want to improve the display of a specific ScriptableObject or Component in the Inspector. [CustomPropertyDrawer(typeof(LootTable))] with weight visualization as a small histogram right in the Inspector — that's a few hours of work that saves hours of confusion for the game designer.
How we built a dialogue editor for an RPG — a case from practice
A graph-like dialogue editor is the most requested type of tool. Requirements: nodes with speech text, choice branches, conditions (flag checks, progress), localization. The project had 50+ nodes, 20 types of conditions — the editor cut dialogue input time by 3x.
The standard approach is based on the GraphView API (namespace UnityEditor.Experimental.GraphView). GraphView provides pan, zoom, select, copy-paste out of the box. Custom Node classes inherit from UnityEditor.Experimental.GraphView.Node, ports (Port) define inputs and outputs.
The problem with GraphView: it has been marked as Experimental since Unity 2019 and has officially never become stable. This means potential breaking changes when upgrading the engine. Alternatives for new projects are xNode (open source) or a custom implementation on UI Toolkit with custom drag logic.
Dialogue data is stored in ScriptableObject with [SerializeReference] for polymorphic storage of different node types — this allows serialization of inherited types without wrappers and avoids type loss during deserialization. If dialogues need to be edited outside Unity (by a narrative designer without the Editor) — we use JSON with custom serialization or yarn/ink formats with a parser on the Unity side.
How does validation prevent errors?
A tool without validation shifts responsibility for data correctness to the person — that always leads to errors. Three levels of protection:
Inline validation in the editor. [Required] attribute via a custom PropertyDrawer that draws a red border around empty mandatory fields. Visible immediately, before saving. Inline validation reduces editing-time errors by 90%.
Pre-build validation. IPreprocessBuildWithReport.OnPreprocessBuild() — a method called before each build. We iterate all ScriptableObject assets of the required type via AssetDatabase.FindAssets, check mandatory fields, null references, duplicate IDs. If an error is found — we throw BuildFailedException with a description of what and where is broken. The build does not start with broken data.
Runtime assertions. In Debug builds: Debug.Assert(quest.reward != null, $"Quest {quest.id} has null reward"). Cheap and catches what passed through the first two levels.
Inline validation code example
```csharp [CustomPropertyDrawer(typeof(LootTable))] public class LootTableDrawer : PropertyDrawer { public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(position, label, property); // drawing with validation EditorGUI.EndProperty(); } } ```Custom Gizmo and Scene View Tools
For level editors: custom Handles in Scene View via Handles.DrawWireCube, Handles.DrawBezier, HandleUtility.PickGameObject — allow visualizing game data directly in the scene. Spawn zones, patrol paths, trigger zones — editable via drag in Scene View, not via numbers in Inspector.
[DrawGizmo(GizmoType.Selected)] attribute draws a custom Gizmo without OnDrawGizmos() on the component — cleaner architecture.
What is included in the work
| Stage | Result | Approximate time |
|---|---|---|
| Data structure analysis | Editor specification and data schema | 1–2 days |
| Interface prototyping | Mockup in UI Toolkit or Figma | 2–4 days |
| Core implementation | CRUD functionality, validation, serialization | 3–10 days |
| Project integration | Connection to existing systems | 1–3 days |
| Documentation and training | User manual and video session | 1–2 days |
Timelines
| Tool | Time |
|---|---|
| CustomEditor / PropertyDrawer for existing type | 1–3 days |
| Simple EditorWindow (data table + CRUD) | 3–7 days |
| Graph editor (dialogues, quests) with medium complexity | 2–4 weeks |
| Full Level Editor with validation and gizmos | 3–8 weeks |
The cost is calculated after describing functional requirements and analyzing the game data structure. The tool pays for itself within 2–3 months by reducing content errors. We have over 5 years of gamedev experience and more than 30 implemented tools for studios of various sizes. Assess how a custom tool can speed up your team's workflow. Ready to discuss your editor? Contact us for a detailed evaluation.