ORDO User Manual

Version 1.3.1 · Updated October 6, 2026

Template-driven project organization and supported engineering-readiness checks for the Unity Editor.

Start here: Open Tools → ORDO → Open ORDO. Overview always presents the next recommended action.

Installation and first run

1. Commit or back up the project.
2. Import ORDO-1.3.1.unitypackage with the full Assets/FaktoryStudios/ORDO subtree selected.
3. Wait for Unity compilation to finish, then open ORDO.
4. If Overview shows Set Up ORDO, open Settings and install a starter template, select an existing template, or create a blank one.
5. Choose Create Project Folders. Once the configured folders exist, the primary action advances to Scan Project.
6. Review Auto Organize (in the header, next to Scan) and script approval, then run the first scan.

Without a template, ORDO can still inspect prefab missing scripts. Organization and import-policy enforcement require an active template.

The workspace

Tabs across the top switch between the four areas below; a number on a tab is how many items it holds. The header under the tabs always shows the current project, the Auto Organize on/off control, and Scan Project / Scan Again. The ⋮ menu at the far right opens this manual, toggles Auto Organize, and links to the ORDO website.

Overview

The recommended next step beside your Blocking, Warning, and Advisory counts; what changed since the previous scan; the most important findings; and pending, template, coverage, and automation status.

Findings

Findings grouped by severity. Selecting one shows its rule, what was expected versus what ORDO found, the asset path with Locate Asset, and the fix or guidance.

Pending Changes

Exact asset moves awaiting approval, including preflight, batch results, and Keep Here exceptions.

Settings

Your project's rulebook and ORDO's daily behavior: the active template, import policies, the shareable policy file, automation switches, and exceptions. See the Settings guide.

The installed ORDO version is shown at the right of the tab bar (for example v1.3.1) and at the top of the ⋮ menu. Include it when you send feedback or report a bug.

How Scan works

1. ORDO compares the location of files in the folders it organizes with the active template.
2. Every misplaced file is proposed in Pending Changes. A scan never moves a file that was already in your project; you approve the moves.
3. ORDO evaluates supported health coverage.
4. The window routes to the highest-priority result: scan error, pending changes, findings, or clean Overview. A summary slides in at the bottom-right — findings, moves awaiting approval, and import settings updated — with a shortcut to what needs you next. It hides itself after a few seconds (hover to keep it), or close it with ×.

Scan never deletes project files. Move failures leave the source asset in place and report details in the Console.

If ORDO cannot detect version control for the project, Overview shows a reminder to commit or back up before running Scan or applying pending changes. ORDO moves files and can rewrite importer settings, and those changes are easiest to review or roll back with a clean commit beforehand. Settings › Project setup has an Add .gitignore button that writes Unity's recommended .gitignore to the project root.

What changed since the last scan

ORDO keeps a snapshot of your last fully completed scan and compares each new scan against it. Overview's Since previous scan card shows how many findings are new, resolved, and unchanged.

• Your first completed scan establishes the baseline; existing findings are not reported as new.
• A scan that is cancelled or cannot inspect everything never replaces the baseline, so the comparison is always against a scan you can trust.
• The snapshot is stored in Library/ORDO/readiness-baseline.json. Unity's Library folder is local to each machine and is not committed, so each developer has their own baseline. Deleting it simply starts a new baseline on the next scan.

Pending Changes safety

Each proposal shows the file, its destination folder, and where it comes from; hover for the full paths. Use a row's Apply to make just that move (other proposals stay queued), or Apply All when nothing is blocked. The ••• menu on a row locates the source, shows a destination conflict, changes the destination, or copies the paths.

Before applying, ORDO verifies that each source still exists, the exact destination is valid, and the move can proceed. Batch results distinguish applied, failed, and unattempted work. Review every destination before approval and commit important projects before bulk changes.

Findings and remediation

ORDO checks texture mipmaps, filter mode, and anisotropy; model Read/Write, global scale, mesh compression, and animation (rig) type; audio load type, compression format, force-to-mono, ambisonic, and import quality; missing MonoBehaviour scripts and serialized object references whose target no longer exists, in prefab assets and in scenes.

• Import-policy fixes (texture, model, audio) are confirmation-gated, reread current state, change only the governed importer property, trigger reimport, and require rescan verification.
• With Apply Import Policies on, most import-policy findings only appear when an asset was changed by hand after import; Apply Import Policies Now clears the existing backlog.
• Prefab missing scripts are Blocking and guided. ORDO does not automatically remove serialized components.
• Missing object references are Warnings and guided — a field that was assigned and whose target has since been deleted. A field that was always empty is not reported. ORDO never reassigns or clears a reference for you.
• Scenes get their own Scene Integrity group: missing scripts on scene objects (Blocking) and missing references (Warning), same guided handling as the prefab checks. Scenes are checked when they are open, or when ORDO can safely open them (not in Play mode, no unsaved changes); otherwise it reports partial coverage rather than skipping silently.
• Evaluation errors are different from findings and prevent ORDO from presenting an unreliable clean result.

Scope: No findings means the checks shown by ORDO are clean. It does not mean every aspect of the project is ready to ship.

Settings guide

Settings is where you tell ORDO how your project should be organized and imported. It has two groups, in the order you'll normally use them: Setup (one time) — template, import policies, project setup, and the shareable policy file — and Daily behavior — what ORDO does automatically and what it should leave alone. Each section in the window has a Learn more link to its part of this chapter.

New to ORDO? You only need three clicks: under Active template choose Install Starter Templates (if no template is selected yet, it selects Starter_3D_Desktop; pick another from the Template field if your project is 2D, mobile, VR, AR, console, or WebGL), then Create Project Folders, then Scan. The defaults under Daily behavior are safe: new assets in the folders ORDO organizes are filed automatically, files already in your project are only proposed for your approval, and nothing is ever deleted. Come back to the rest of this chapter when you want to change how ORDO behaves.

Where settings are stored, and what is shared

Active template

In short: a template is ORDO's rulebook for your project — which folder each kind of asset belongs in, and which import settings each folder's assets should have. Everything ORDO organizes or enforces comes from the active template.

Why it matters: Unity lets any file live anywhere and keeps whatever import settings it was given. Over time that drifts: textures land in the project root, a UI sprite gets imported as a normal texture, a model keeps Read/Write on and doubles its memory. A template writes your conventions down once, so ORDO can file new assets, fix import settings as assets arrive, and report anything that still doesn't match. With no template, ORDO can still scan prefabs and scenes for missing scripts and broken references, but it cannot organize or check import settings.

What a template contains

A template is a normal Unity asset (a FolderStructureTemplate) with a list of folder rules and a table of extension overrides.

Extension overrides map a file type straight to a folder (cs → Scripts, png → Art/Textures). They are the catch-all for that file type: a file goes to its override's folder unless a wildcard rule claims it first.

How ORDO picks a folder for a file

1. A file outside the folders ORDO organizes, or with a Keep Here exception (see Organization exceptions), is left where it is.
2. A folder rule whose name wildcards match the file supplies the destination. When several match, the highest priority wins, then the longest pattern, then the rule listed first. Wildcards use * and ? and match the file name with or without its extension, so *Manager*, *Manager, and *Manager.cs all match GameManager.cs.
3. Otherwise, an extension override supplies the destination for that extension.
4. Otherwise, the first folder rule (in template order) that accepts the extension supplies the destination.
5. For a texture, any rule or override whose folder expects the other kind of texture (Sprite versus plain) is skipped at each step, and a rule that expects exactly its kind is preferred over one that takes any.
6. Assets without a matching destination remain in place. Unity's own scaffolding (Assets/TutorialInfo, Assets/Readme.asset) is always left alone.

The starter templates

Install Starter Templates adds seven ready-made templates to Assets/FaktoryStudios/ORDO/Templates. They share one backbone — Art/Textures (Art/Sprites in 2D), Art/Materials, Art/Models, Audio, Prefabs, Scenes, Scripts, Shaders, Settings, Tests, Plugins, and UI — and differ mainly in import policies tuned for the target platform:

Every starter maps images to the texture folder by extension override, so a plain-texture PNG in UI/ is proposed for Art/Textures. Sprites are handled differently: a sprite goes to a folder that expects sprites (UI in the 3D starters, Art/Sprites in 2D), never to one that expects plain textures. To keep other images in UI/, give the UI rule a wildcard such as UI_* and name them to match, or add a Keep Here folder exception for Assets/UI.

Customizing a template

• Edit Template Asset selects the active template in the Project window; change rules and overrides in the Inspector. Import policies are easier to edit in Settings › Import policies.
• Validate Template checks the rules: empty or Assets/-prefixed paths, duplicate paths, extensions with dots or capitals, rules that overlap on the same extension, overrides that point at a folder no rule defines, mismatched override lists, and conflicting import policies (two load types on one folder, for example). Fix errors before scanning; warnings are advisory.
• Create Project Folders creates any missing template folders. It never moves or deletes files.
• Create Blank Template makes a new template with a generic layout you can reshape; to start from a starter instead, duplicate its asset (Ctrl/Cmd+D) and select the copy.
• Re-running Install Starter Templates later merges into existing starter assets: your extra rules and policy tags are kept, missing folders are added, and the starter's extension overrides are restored. If you changed a starter's overrides, work on a duplicate instead.

Sharing a template

Commit the template asset with the project and everyone on the team uses the same rules. For a reviewable, project-independent copy — to reuse your conventions in another project, or to see rule changes in a pull request — export the shareable policy file.

Import policies

In short: import policies are per-folder import settings — "everything in Art/Models has Read/Write off and scale 1", "everything in UI is a sprite without mipmaps." ORDO applies them as assets arrive and reports anything that drifts.

Why it matters: Unity's default import settings are rarely the right ones for a shipping game, and fixing them one asset at a time doesn't scale. Wrong texture compression, mipmaps on UI, Read/Write left on, or uncompressed audio quietly cost build size, memory, and load time — and they're easy to miss in review. Policies make the right setting automatic for every asset in a folder, including ones added months later by someone else.

How they work

1. On import: with Apply Import Policies on (Daily behavior), every texture, model, or audio file imported into a folder gets that folder's policies before Unity finishes importing it.
2. For assets already in the project: Apply Import Policies Now brings every eligible existing asset into line once and reports how many changed.
3. Afterwards: each scan checks assets against their folder's policies. A mismatch — usually a setting someone changed by hand — becomes a Warning in Findings with a one-click, confirmation-gated fix.

Policies never move files, and they skip assets under Packages, Editor folders, ORDO's own folder, and anything with a Keep Here exception.

Seeing what policies changed on import

Policies are applied automatically, but never silently. Every import setting a policy changes on import is recorded: the asset, the importer, the setting, its old and new value, the policy, and the time.

• A notice per import, not per asset. When an import finishes, ORDO shows one brief notice at the bottom-right of its window — for example "3 import settings changed on 2 assets" — however many assets were imported. It never opens a dialog or takes focus. If the ORDO window is closed, it writes one summary line to the Console instead.
• Overview shows "ORDO applied N import changes since your last scan" with View details. The details list every change grouped by policy, with Locate Asset to select the asset and review its import settings. Scanning resets the count; the history stays available from Overview's Configuration card.
• Notify When Policies Are Applied on Import (Settings › Organization behavior, on by default) turns the notice and Console line off. Changes are still recorded and listed on Overview.
• The record is kept in Library/ORDO/import-changes.json, local to each machine and never committed. It holds the most recent 2,000 changes; deleting it only clears the history.
• Changes made by Scan, Apply Import Policies Now, or a fix in Findings are reported by those actions and are not repeated here.

Customizing

• Expand Import policies, pick a folder rule, and add or remove policies. Only policies that fit the folder's file types are offered (texture policies for image folders, and so on). The full list is in the import policy reference.
• Some policies are mutually exclusive — one audio load type, one mesh compression level. Choosing one replaces the other, and Validate Template flags any conflict.
• Advanced · raw tags shows the folder's whole tag list. Besides built-in policies it can hold custom tags for your own import scripts.
• To turn enforcement off without losing your policies, switch off Apply Import Policies; Findings will still report mismatches.

Sharing

Policies are part of the template, so they travel with the template asset and with the shareable policy file.

Project setup

Add .gitignore downloads Unity's recommended .gitignore (from github.com/github/gitignore) to the project root, so generated folders such as Library and Temp stay out of version control. ORDO asks before replacing an existing file. If Overview warns that no version control was detected, set up Git (or your VCS) before letting ORDO move files — a commit is the simplest undo for any bulk change.

Shareable policy file

In short: one small JSON file that holds your template's rules, extension overrides, and import policies, plus the Apply Import Policies setting. Commit it, and every copy of the project can be checked against — and updated from — the same configuration.

How it works

• Export Policy File… writes the active template's configuration to ProjectSettings/ORDO.policy.json by default. The file is sorted and pretty-printed, contains no GUIDs or machine-specific paths, and exporting an unchanged configuration produces an identical file — so diffs show only real changes.
• Import Policy File… reads a policy file and opens the Update readiness policy review page: rules added and removed side by side, rules changed, enforcement changes, and anything that needs attention — validation problems, or import-policy tags ORDO doesn't recognize, which are kept but not applied. Nothing changes until you choose Apply Policy Update. Applying overwrites the active template's rules and import policies; assets are not moved or reimported until your next scan or Apply Import Policies Now.
• Drift check: when the project has a committed ORDO.policy.json, ORDO compares it with the live template each time the window opens and shows a dismissible notice if they differ. Check Sync runs the same comparison on demand. The notice never blocks anything.
• Not included: which template asset is selected, Daily behavior switches, and organization exceptions — those are project-local choices in ORDOSettings.asset.

Everything works offline and needs no account.

How teams use it

• Solo developers: export once and commit it. It documents your conventions, survives template edits you might regret (re-import to roll back), and lets you start the next project with the same setup in one import.
• Small teams: one person owns the rules. When they change, re-export and commit; teammates who pull the change see the drift notice and apply the update from the review page. Everyone stays on the same folder layout and import settings without passing screenshots around.
• Larger teams and studios: treat the policy file like code. Changes arrive by pull request, where the JSON diff shows exactly which rules and import settings changed. Keep one studio-wide policy file and import it into each new project for consistent standards across teams. Pair it with the command-line scan in CI so a build fails on Blocking findings.

Organization behavior

These switches decide what ORDO does on its own, every day. The defaults suit most projects; change them when you want more control.

When ORDO queues a script or moves a new one, it writes a line to the Console saying where it goes and why. All moves go through Unity's AssetDatabase, so references, prefab links, and scene assignments survive. ORDO never deletes files. Apply Import Policies Now (available once a template is active) updates existing assets; Review Pending Changes appears when moves are waiting.

Folders ORDO organizes

In short: ORDO only moves files in places you have said are yours. Imported and third-party assets keep the folder layout they depend on.

A file is organized only when it is:

• loose in Assets (not inside any folder);
• inside one of the template's own folders, such as Scripts or anything under Art; or
• inside a top-level folder you ticked in Settings › Folders ORDO organizes.

Ticking a folder also tells ORDO it is yours even if it contains an assembly definition, so its textures, materials, and other assets can be organized. Its scripts still stay with their assembly.

Proposals always follow the current rules: if you untick a folder, add an assembly definition, or add an exception, queued moves that are no longer allowed are removed from Pending Changes (with a line in the Console), including any left by an earlier ORDO version.

When two proposed files would land on the same name, the second is proposed as name 1.ext so one clash never blocks the rest. Scripts are the exception: a script's file name has to match its class, so ORDO never renames one. A script that would clash is left where it is, with a warning in the Console, for you to resolve.

A move you approve in Pending Changes is final, including one where you chose a different destination: Auto Organize does not re-file it. If ORDO cannot file a new file automatically, it says why in the Console and adds it to Pending Changes instead of leaving it unfiled.

Every other folder is left exactly as it is. The list shows each top-level folder with ORDO's best guess about it and the reason — Asset Store package (recent Unity versions record this when a package is imported), has its own assembly definition, looks like an imported package, Unity or third-party folder, or looks like your content. The guess only helps you decide; nothing is organized because of it. Ticking a folder that looks third-party asks you to confirm first.

This is about moving files, not checking them. Findings inspects the whole project either way, and import policies only ever apply inside the template's folders.

Undoing a run

ORDO keeps a local record of the moves it makes (Library/ORDO/move-journal.json, never committed, last 20 runs). Last organize run … Undo on Overview and in Pending Changes moves the files from the most recent run back to where they were, after a confirmation. Files are found by Unity's asset ID, so the undo still works if you renamed one since. It does not revert import settings changed by a folder's import policies, and a file is skipped (and listed in the Console) if something else now occupies its old path.

In Pending Changes, By source folder groups the proposals by the folder they would leave, with Keep Folder Here to dismiss a whole folder at once.

Assembly definitions and packaged assets

An assembly definition (.asmdef) or reference (.asmref) assigns the scripts in its folder to an assembly, so where it sits is what it means. ORDO protects that automatically:

• Assembly definition files are never moved.
• A script is never moved out of its assembly. Moves inside the same assembly — Scripts/Player.cs to Scripts/Player under one definition — still happen.
• Packaged assets stay together. When a folder outside your template's folders contains an assembly definition, as an imported asset or a self-contained module does, ORDO leaves that whole folder in place: its scripts, materials, shaders, scenes, and documentation. The folder is the top-level one under Assets that holds the definition, for example Assets/SomeAsset when the definition is in Assets/SomeAsset/Runtime.

Unity's special folders are never emptied. Unity gives some folder names a meaning — assets load from Resources by path, StreamingAssets ships as-is, Editor decides which assembly a script joins — so ORDO never moves anything out of Resources, StreamingAssets, Editor, Editor Default Resources, Gizmos, Plugins, Standard Assets, or WebGLTemplates, wherever they are in the project.

Sprites and plain textures are kept apart. A folder rule can expect Sprite or Default textures, and its import policies enforce that. ORDO only files a texture into a folder that fits it: a UI sprite goes to the folder that expects sprites (UI in the starter templates), never to one whose policy would turn it into a plain texture. If no folder fits, the texture stays where it is.

Shader includes get the same care. Shader source finds its include files by path rather than by Unity's asset IDs, so ORDO never moves an include file (.cginc, .hlsl, .glslinc) and never moves a .shader, .compute, or .raytrace file that includes a file relative to its own folder. Shader Graph assets are organized as usual.

Overview's Configuration card shows Left in place with the number of such folders; hover it for the list. This is "don't move", not "don't check": Findings still reports on those assets. An assembly definition inside one of your template folders, such as your own game assembly in Scripts, does not stop the other assets around it from being organized.

Organization exceptions

Exceptions tell ORDO to leave something where it is — a third-party asset pack that expects its own folder layout, generated files, or one asset that genuinely belongs somewhere unusual.

• Folders: nothing inside these folders (recursively) is moved. Assets/FaktoryStudios is listed by default so ORDO never reorganizes itself. Use Add Selected Folder for the folder selected in the Project window, and Normalize and Dedupe to tidy the list.
• File types: extensions (without a dot, e.g. json) that are never moved anywhere in the project.
• Individual assets: single assets kept in place. They are remembered by GUID, so the exception survives renames and moves. Remove one here at any time.

The quickest way to add an exception is Keep Here… on a row in Pending Changes, which offers Only this file, All .png files (for that file's type), or Everything in its folder.

What an exception changes: ORDO won't move the asset and won't rewrite its import settings. What it doesn't change: scans still inspect it, so Findings can still report its import-policy mismatches, missing scripts, and broken references. An exception means "don't touch", not "don't check".

Import policy reference

Each policy on a folder rule is applied to matching assets on import (when Apply Import Policies is on) and checked in Findings afterward. A rule may also carry custom tags with no built-in profile; ORDO stores them but takes no action (see Custom import tags). Clean-state claims are limited to the policies below.

Texture policies

Model policies

Audio policies

Custom import tags (advanced)

Every folder rule has one tag list. The policies you pick in Settings are written into it, and Settings › Import policies › Advanced · raw tags shows and edits the whole list as text. Below the field, ORDO shows which tags it applies and which are custom.

• Separate tags with commas (semicolons work too). Case doesn't matter: UI and ui are the same tag.
• Built-in tags are the ones in the import policy reference. Typing one here is the same as choosing that policy in the list.
• Any other word is a custom tag. ORDO keeps it on the rule, includes it in the shareable policy file, and keeps it across upgrades, but never changes an asset because of it, and Findings never checks it.
• Give custom tags a prefix of your own, such as mystudio-, so they never collide with a built-in tag added in a future ORDO version.

Acting on a custom tag

Custom tags let your own import rules follow ORDO's folder structure. Put an AssetPostprocessor in any Editor folder and ask ORDO which tags apply to the asset being imported:

using System.Linq;
using Faktory.ordo;
using UnityEditor;
class StudioImportTags : AssetPostprocessor
{
    void OnPreprocessTexture()
    {
        // Rule in ORDO: Art/Lightmaps, raw tags "nomipmaps, mystudio-lightmap"
        if (OrdoImportTags.ForAsset(assetPath).Contains("mystudio-lightmap"))
        {
            var importer = (TextureImporter)assetImporter;
            importer.textureType = TextureImporterType.Lightmap;
        }
    }
}

• OrdoImportTags.ForAsset(path) returns the governing rule's tags in lower case, built-in and custom. It returns nothing whenever ORDO would not apply import policies to that asset: no active template, Apply Import Policies off, no matching rule, or the asset is under Packages, an Editor folder, ORDO's own folder, or a Keep Here exception.
• OrdoImportTags.IsBuiltIn(tag) tells you whether ORDO itself applies a tag; OrdoImportTags.Parse(text) splits a tag field the same way ORDO does.
• Scripts in the default Assembly-CSharp-Editor see ORDO automatically. If your editor code is in its own assembly definition, add a reference to Faktory.ORDO.Editor.
• ORDO's built-in policies run on import too. Avoid changing the same importer setting from a built-in tag and your own script.

Command line

ORDO can run its readiness scan headless, for a build server or a pre-release check:

<unity> -batchmode -quit -logFile - -projectPath <project> \
        -executeMethod Faktory.ordo.OrdoCli.Scan \
        [-ordoReport <path>] [-ordoFailOn blocking|warning|none]

• The scan is read-only — it evaluates the project and writes a report. It never moves assets, changes importers, or saves scenes.
• It writes the same structured JSON report the Editor produces, to -ordoReport (default ordo-readiness-report.json in the project root).
• The report's importChanges block lists any import settings that import policies changed while Unity imported the project for this run (counts, a per-policy breakdown, and each change). It is empty when nothing changed.
• Exit code: 0 clean, 1 a finding at or above the fail threshold (Blocking by default; set -ordoFailOn to also fail on Warnings, or none to only report), 2 the scan could not check everything, 3 ORDO threw.
• With no template configured, the scan still runs the prefab and scene integrity checks.

Included organization demo

Open Assets/FaktoryStudios/ORDO/Samples/Organization Demo for a sample texture and guided exercise. ORDO protects its own package folder, so duplicate the texture into the project root to try automatic organization or an approval-gated move.

Troubleshooting

Assets do not move

ORDO moves a file on its own only when all of these are true:

• a template is active and Auto Organize is on;
• the file is new to the project (you created it or dropped it in) or you just moved it yourself — files that were already there are proposed by Scan in Pending Changes, never moved;
• it is in a folder ORDO organizes: loose in Assets, in a template folder, or in a folder you ticked;
• the template has a destination for its file type, and for a texture, a folder that fits its type (Sprite or plain);
• no asset, extension, or folder exception matches; and
• nothing protects it: it is not an assembly definition or a script that would leave its assembly, not in a packaged asset's folder, not in Resources or another special folder, and not a shader tied to an include file beside it.

A file whose folder you moved or renamed is treated as existing content: Scan proposes it.

The Editor pauses after adding a very large number of files

When you create or drop thousands of new files into a folder ORDO organizes with Auto Organize on, ORDO files them all in one batch as soon as Unity finishes importing, and the Editor does not respond until the batch is done. In testing, about 2,000 new files took roughly half a minute to file, on top of Unity's own import. Nothing is lost: every file is filed, and the whole batch is a single entry for Undo.

To avoid the pause for a large import:

• turn Auto Organize off first, import, then run Scan and apply the proposals when it suits you; or
• import into a folder ORDO does not organize, and tick it in Settings › Folders ORDO organizes later if you want it organized.

Applying a few thousand proposals at once in Pending Changes, or undoing a run that size, pauses the Editor in the same way for a shorter time.

A move is always queued

Script approval may be enabled, or Auto Organize may be off. Review Settings and the exact proposal in Pending Changes.

A proposed destination is wrong

Use Keep Here for an intentional exception, or edit and validate the template when the rule itself is incorrect.

A scan reports an inspection error

Overview lists the first few assets ORDO could not inspect and why; Findings › Evaluation errors has the full list. Correct the underlying import or serialization problem, then scan again. Until a scan completes without errors, ORDO does not show a clean result or update the Project Health baseline.

Feedback and support

The ⋮ menu has Leave a Review, which opens ORDO's Asset Store page, and Send Feedback… / Report a Bug…, which open a short form in your browser with your ORDO, Unity, and OS versions already filled in. No email program is needed. Bug reports with steps to reproduce are the fastest way to get a fix into the next update.

After you have run a few scans, Overview may show a small Enjoying ORDO? card right after a clean scan or one that resolved findings. It never interrupts a scan or opens anything on its own. Not now hides it for a while; Don't ask again, leaving a review, or sending feedback hides it for good. The choice is saved for you on this computer, not in the project.

Uninstall

Close ORDO and remove Assets/FaktoryStudios/ORDO. Back up first so any ORDO-created configuration and prior asset moves can be reviewed deliberately.

© 2026 Faktory Studios LLC. All Rights Reserved.