Find and fix errors in Unity

The Most Powerful Validation Tool Ever Made for Unity

Try it for Free Buy Odin

Move fast without breaking things

Odin Validator is a powerful tool for both finding and fixing errors and bugs in your projects.

It is set up to work right out of the box, but can be customized to specific needs in a number of different ways.

It scans your projects in real-time while you work on your project, allows for bulk fixing, and is capable of fixing thousands of errors at the click of a button.

Realtime Background Validation

Odin Validator scans your project in the background, keeping you up to date without getting in your way.

Validation On Demand

Run a dedicated scan of any part of your project fully with one click, even scanning currently closed scenes.

Automated Validation

Use built-in hooks to validate profiles at build, play or project load, or use a simple API to write your own.

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.

- Riley George, Software Engineer - Imangi Studios

Quick validation with Odin Visual Designer

Odin Validator can easily be customized using Odin’s Visual Designer Set up custom validation without the need for writing code, using the built in validation attributes

Easy for developers

Odin Validator works right out of the box with no setup required. Once you’re ready to go beyond the default setup and rules, simply add attributes from the built-in library, and you’re set.

Built on Odin Inspector’s proven systems, Odin Validator lets developers easily define validation logic, criteria, and fixes through the same intuitive attribute-based approach and extension patterns - such as custom validators, rules, fixes and more.

Easy for designers

A lot of care has gone into making Odin Validator effortless to use, with almost no onboarding required. Everything is managed from a single, intuitive window that lets designers jump straight in - issues appear seamlessly through scene widgets and inspector-integrated issue notifications.

It can also be customized to further streamline design workflows, such as blocking play mode when errors are detected, provide automated fixes, highlight selevted issues directly in the scene view and much more.

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.

Detect missing references

Detect shader compiler errors

Detect broken prefab connection

Detect broken assets

Detect duplicate components

Detect invalid layer assignments

Detect broken materials

Detect invalid renderers

Detect invalid positions

Detect invalid Unity events

Detect use of obsolete components

Detect missing scripts

Support for all validation attributes

Setting up powerful custom validation is as simple as taking a second to add a few attributes. Almost anything you’ll need is already included in our built-in library of functionality.

[Required]
[RequiredIn]
[AssetsOnly]
[MinValue]
[MaxValue]
[Range]
[Obsolete]
[ValidateInput]
[FilePath]
[FolderPath]
[MinMaxSlider]
[DontValidate]
[DisallowModificationsIn]
[ChildGameObjectOnly]
[SceneObjectsOnly]
[RequireComponent]

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.

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

Create as many validation profiles as you need, each tailored to specific tasks, roles, or workflows. Switch between them instantly, and only the assets and issues relevant to your current work are scanned and shown - keeping validation focused and noise-free.

Goes beyond finding errors & fixing bugs

Refactor safely & quickly

Odin Validator goes beyond error detection. It lets you express changing requirements as validation rules - instantly finding every refactor point and verifying that the new setup works. Massive project updates can be done safely in minutes instead of over days.

Merge safely & quickly

Merging feature development streams is often risky, but with a solid validation setup, many common errors introduced by combined changes can be caught immediately - rather than surfacing weeks later in 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.

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, flexible tools can easily lead to fragile setups, unlike hard-coded but limited systems. To avoid misuse, programmers often restrict access or rely on extensive documentation and training - both time-consuming and error-prone.

With Odin Validator, programmers can define clear limitations and requirements, automatically ensuring tools are used correctly. Validation messages and quick fixes guide designers directly within the editor, turning the tools themselves into teachers and eliminating much of the human error and overhead.

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

var profile = AssetDatabase.LoadAssetAtPath<ValidationProfile>("Assets/Path/To/Validation/Profile.asset");
using (var session = new ValidationSession(profile))
{
    foreach (var result in session.ValidateEverythingEnumerator(openClosedScenes: true, showProgressBar: false))
    {
        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());

Frequently updated

We've maintained and actively developed Odin for 9 years, and are planning on maintaining it for many years to come! Check out the online roadmap to learn more about the future of Odin.

Try it for free Roadmap