Odin Validator

Find and fix errors in Unity





Move fast without breaking things!

Find issues on the fly

Odin Validator detects any changes made to assets and scenes in the project and validates them live in the background, keeping you up to date as you work without getting in your way.

Find issues on demand

When live validation isn't enough, run dedicated scans, scanning even closed scenes, and quickly get an overview of the state of any part of your project that interests you.

Automate issue detection

Odin Validator comes with the built-in ability to run automatically at build, play or project load, and is quick and easy to integrate into your own CI systems in as little as one or two lines of code.

Easy for developers

Odin Validator works right out of the box after importing, with no setup or configuration required to get started. Once you move past the out-of-the-box validation setup and rules, it's as simple as adding a one-line attribute declaration using the built-in library of building block attributes, and you're good to go.

Odin Validator builds on the tried and true patterns and existing systems of Odin Inspector to let your developers specify and build out validation logic and criteria and specify fixes as easily and quickly as Odin Inspector lets them build useful tools and editors, through attributes and powerful yet simple extension patterns like custom validators, rules, fixes and more.

Easy for designers

Enormous effort has gone into polishing and tuning every part of the experience of working with Odin Validator to require next to no onboarding or introduction to get started. Everything is accessed from a single window with an intuitive UI that lets designers get right to work. They are seamlessly presented with issues as they work via scene widgets and issue notifications integrated into the inspector.

Odin Validator can be further configured to make life easier for designers in a variety of ways, such as preventing entering play mode while there are detected errors in the scene, provide automated fixes for a wide variety of issues, highlight selected issues in the scene view, and so on.

High quality built-in rules

Odin Validator comes with several built-in, configurable rules, which can be enabled,
disabled and configured on both a team-wide project basis, or on a local machine-only basis.

Over time, this list will grow, be improved upon and kept updated as Unity releases new features and packages.



Detect missing references

Detect broken assets

Detect duplicate components

Detect invalid layer assignments

Detect shader compiler errors

Detect broken materials

Detect renderers with invalid materials

Detect invalid transform positions

Detect broken prefab connections

Detect scenes not in build settings

Detect use of obsolete components

Detect missing scripts




Out-of-the-box support for all validation attributes

Odin Inspector, Unity and .NET itself already come with several attributes which can be validated.
Odin Validator has support for all of these attributes, and more are added on an ongoing basis.



Required

RequiredIn

ValidateInput

AssetsOnly

SceneObjectsOnly

ChildGameObjectsOnly

DisallowPrefabModifications

MaxValue

MinValue

Range

MinMaxSlider

RequireComponent

Obsolete

FilePath

FolderPath




Refactor safely and quickly

Odin Validator is not limited to finding errors. Changing requirements can easily be expressed in validation, letting you both find every point where a refactor requires changes, and continually ensures the new setup is correct. Huge project can be carried out safely in minutes, instead of precariously over days.

Merge safely and quickly

Merging together feature development streams is always precarious, but with a solid validation setup, many common errors introduced when different changes are merged together can be caught right away, instead of weeks later during testing.

Upgrade Unity versions safely

Data corruption, import issues, missing asset references, and more often plague the project version upgrade process. Odin Validator helps detect and resolve these issues for a more robust and safe project upgrade path.

 

Odin has allowed us to focus on what really matters: building our games and the tools that support them. Its API is so simple and easy to use that much of our custom inspector and project validation work has gone from taking days to taking minutes.

Ryan George, Software Engineer
Imangi Studios
 

Built for scale

Odin Validator is built from the ground up to support and thrive in massive projects with many thousands of assets.

  • Handles displaying and filtering hundreds of thousands of issues with no lag
  • Scans only the parts of the project you are currently interested in using validation profiles
  • Background scanning ensures that even in huge projects, validation never gets in your way as you work
  • Scans almost as fast as the asset database can load assets

Bulk fix issues

With bulk fixing, you can run thousands of fixes at once. Simply filter to the set of fixes you want to run, enter any inputs if needed, and press go. You can be as specific or broad as you like, but never again do you have to go find every single instance of an easily solved issue and handle them individually.

Bulk fixing is also a great way to refactor. Imagine adding a new validated requirement that some component must now be on specific gameobjects, of which you have thousands in the project, spread out across hundreds of scenes and prefabs. With a single bulk fix operation, all of those thousands of components can be added and configured correctly in a matter of seconds, when doing this manually would have taken days or weeks, and been prone to human error and missed cases.

Seamless scene switching

When clicking through and highlighting issues in the validation view, Odin Validator can seamlessly switch scenes and open prefab stages and focus the camera to bring you to exactly where the issue is with an absolute minimum of hassle and interruption to your workflow.

Right click > Validate this

For when you only want to be validating certain things as you go and don't want to set up a new validation profile or tweak the current one, you can simple right-click one or several assets or folders and press "Validate this" to bring up a new validation window which only validates what you selected.

Switch between validation profiles

Validation profiles specify what to include or exclude from validation. Set up as many or as few as you want, each customized for a specific task, role or situation, and switch between them in moments. A scene graphical designer likely only needs validation of the scene itself and the assets they are actively using without being bothered by issues relevant to other parties, while someone importing textures and creating materials, or setting up abilities, would have different needs. Using profiles, only assets and issues relevant to what you are currently doing are ever scanned and presented.

Export results

Export validation results to HTML or JSON reports to generate human-readable reports and issue overviews or integrate with CI or other issue tracker systems.



Give designers creative freedom without sacrificing robustness and stability

Giving designers powerful, open-ended tools that can do a lot is often very fragile, as opposed to hard-coding robust but more limited behaviour into the game. Often, flexibility is traded for robustness by programmers reluctant to expose fragile values and the inner workings of game systems to designers who may not understand the full picture of how to use them and which limitations apply - or the programmers do expose it all, and designers may get into trouble.

Often, extensive documentation of how to use various parts of the game's tools and systems has to be written, maintained and most importantly read and understood in order to avoid such issues; programmers need to spend valuable time teaching designers, and designers need to spend valuable time learning the particular quirks of the project.

Using a tool like Odin Validator, programmers can very easily specify limitations and requirements, and validate that everything is being used as it should be even when creating and exposing very complex systems. They can provide solid feedback messages and offer fixes for common errors and issues. The tools themselves teach the designers how they should be used, saving precious time for everyone and eliminating countless sources of human error.

Integrates seamlessly into your CI pipeline with just a few lines of code:

var session = GlobalValidationSession.MainValidationSession;
foreach (var result in session.ValidateEverythingEnumerator())
{
    if (result.ResultType == ValidationResultType.Error)
    {
        // Register issue
        Debug.LogError("Error: " + result.Message);
    }
}

Limitless Automation

Odin Validator boasts a simple, robust and open API to make use of and customize all of its features directly from user code. Whether it's a custom CI system, a pre-built validation system that needs to integrate results from Odin Validator, unit and integration testing, and more, the tools are there for any amount of customization and automation to be implemented.

Rich Issue Metadata

An issue in Odin Validator is not just a message and an issue type, but can be a richly featured entity, boasting inspectable metadata, fixes, scene widgets and more.

result.AddError("MeshRenderer in ground layer must have a season material assigned when in a scene with a SeasonCycleManager")
    .WithFix("Set default season material", () => this.Object.sharedMaterial = DefaultSeasonMaterial)
    .WithMetaData("Scene's SeasonCycleManager", seasonCycleManagerInstance, new InlineEditorAttribute())
    .WithMetaData("List of all season materials", seasonCycleManagerInstance.GetSupportedMaterials())
    .WithButton("Create new season material", () => seasonCycleManagerInstance.DoCreateNewMaterialDialog());