Codebase Exporter & Asset Replacer Pro

Codebase Exporter & Asset Replacer Pro is a dual-utility Editor suite designed to streamline data extraction and project-wide dependency management.

Extracting readable data from Unity, or safely tracking down and replacing old architecture, often requires tedious manual file management. This suite saves an incredible amount of time by automating these workflows directly within the Editor.

Core Capabilities at a Glance:

• Rapid Batch Copying: Instantly aggregate dozens of C# scripts, JSON files, or compute shaders into a single, cleanly formatted text payload for external documentation, peer review, or web chat interfaces.
• Preserved Spatial Context: Standard copy-pasting loses Unity-specific data. Extract exactly how scripts are attached to GameObjects, what values are serialized in the Inspector, and what Assembly Definitions govern them.
• Reverse-Dependency Tracking: Quickly locate exactly what scenes or prefabs in your massive project rely on a specific placeholder material or deprecated script.
• Project-Wide Replacements: Execute multithreaded YAML modifications to structurally swap out broken dependencies or obsolete GUIDs across your entire project without needing to open a single scene.
• AI & LLM Optimized: Built-in Regex safely minifies whitespace and standard comments to maximize token efficiency when pasting architecture into AI chat windows.

While the extracted text payloads are highly valuable for standard documentation or review, they are also heavily optimized to serve as token-efficient context for Large Language Models (LLMs) and AI workflows.

Try the Free Lite Versions First

If you have any doubts about purchasing this asset, please consider trying the free, standalone lite versions of these tools on the Asset Store first to see if the workflow is right for you: Clean Script Exporter and Asset Replacer.

While those free tools are fully functional and highly usable for basic tasks, this Pro suite is strictly superior. The paid upgrade introduces massive feature expansions—most notably the Exporter's ability to extract Scene Hierarchies and Inspector Variables, automated text payload chunking, and volatile RAM script backups—as well as deeply integrated cross-tool connectivity that allows the Exporter and Replacer to pass data seamlessly back and forth.

Core Module 1: Codebase Exporter (Data Staging & Formatting)

The Codebase Exporter acts as a centralized staging ground. It rapidly aggregates batches of files, filters out noise, explicitly defines your architectural boundaries, and outputs a cohesive plain-text payload for external review, documentation, or AI analysis.

• Frictionless Staging & Batch Copying: Rapidly aggregate scripts, compute shaders, and GameObjects into dual staging queues. Drag and drop single files or master folders directly into the interface. The ingestion engine relies on strict automated filtration, explicitly enforcing global extension whitelists (e.g., .cs, .compute, .json) and actively rejecting directories that match your custom ignore patterns (e.g., *.meta, Plugins/).
• Independent Workspaces & Preambles: Manage extraction tasks across six independent workspace tabs. Each workspace maintains its own staging queues and a dedicated Custom Preamble scratchpad. You can draft specific instructions or prompts, save them to a version-controlled Instruction Library, and seamlessly append them to the top of your exported text.
• Whitespace & Comment Minification: When pasting code into chat windows or external tools with strict length limits, dead space is restrictive. The engine features smart whitespace minification that strips completely empty lines while preserving structural horizontal indentation. Additionally, a Regex engine safely identifies and strips standard developer comments, while allowing you to explicitly preserve /// XML summaries to ensure formal API documentation remains intact.
• Deep Hierarchy & Variable Extraction: Scripts do not execute in a vacuum. The Hierarchy Extractor parses your queued Prefabs and Scene Objects, generating lightweight ASCII structural maps. Using Unity's native SerializedObject API, it safely extracts surface-level properties (integers, strings, object references) configured on the attached components. To reduce payload size, you can instruct the engine to ignore variables from default Unity namespaces (like Transform or CanvasRenderer) and focus strictly on your custom logic.
• Architecture & Assembly Mapping: The engine can parse the relative physical paths of all staged scripts to generate an ASCII directory tree at the top of your payload. It also traces parent Assembly Definitions (.asmdef), building a one-way dependency map so external readers explicitly understand your project's access rules.
• Payload Formatting & Chunking Protocol: Output your final payload as standard text, Markdown blocks with syntax highlighting, or strict XML tags (<document>). If your staged codebase is massive, enable the Chunking Protocol. By defining a maximum limit, the engine mathematically evaluates your assets and safely severs the payload into sequential text files.
• Volatile RAM Snapshots & Text Backups: Before modifying your source files based on external feedback, take an instant memory snapshot of the active queue. The engine caches the raw text of your scripts into volatile Editor RAM, allowing you to seamlessly revert experimental changes in seconds without breaking Unity's internal GUID meta files. For persistent safety, you can generate timestamped .txt clones directly to your local disk.

Core Module 2: Asset Replacer Pro (Dependency Management)

While the Exporter extracts your architecture into readable formats, the Asset Replacer is built to destructively reorganize and optimize the raw files left behind in your project. It is engineered to track down scattered assets and structurally replace references at scale without requiring you to manually open a single scene.

• Reverse-Dependency Tracking (Asset Locator): Assign a source asset (Material, Texture, Script, or Prefab) to execute a project-wide background scan. Quickly locate every Scene, Prefab, or Material that actively relies on your target.
• Project-Wide Rewiring (Batch Replacer): Instead of manually opening hundreds of materials to swap a placeholder texture for a final asset, the Batch Replacer handles it globally. Drag your "Old" assets into the source column and your "New" assets into the target column to rewire the underlying structural GUIDs. The tool features an auto-pairing algorithm that evaluates filenames, automatically matching incoming targets and stripping common iteration tags (like _v2 or _new).
• Asset Consolidation: If a scan reveals a prefab relying on dependencies scattered across multiple disorganized folders, select them and click consolidate. The engine will physically move the selected assets and all of their underlying dependencies into a unified target directory—automatically structuring them into subdirectories without breaking internal links.
• Package Extraction: Cleanly extract a working subset of assets from a massive project. Bundle your initial source asset, all found dependent assets, and all of their internal requirements into a localized, ready-to-share .unitypackage.
• Simulation Mode (Dry Run): Because Batch Replacement modifies raw file data, the tool defaults to a "Simulate Only" mode. This executes the scan and generates a detailed checklist of affected files, allowing you to review and explicitly exclude specific targets before committing any destructive changes to your hard drive.

Cross-Tool Connectivity

While the Exporter and Replacer operate as independent utilities, this Pro suite features an internal coordination script that allows the two Editor windows to function as a connected pipeline.

• Integrated Context Menus: You do not need to keep the Editor windows open to use the suite. Mass-select any combination of scripts, folders, or GameObjects in your Project or Hierarchy windows, right-click, and navigate to the Veridian menu to instantly route them into the Exporter's staging queues or the Replacer's batch sandbox.
• The Research Bridge (Locator ➔ Exporter): Execute a reverse-dependency scan to find obsolete prefabs relying on a deprecated script. From the Locator's bulk actions, click Send to Bundler. The suite bridges all found dependencies directly into the Exporter queue, allowing you to immediately extract their localized hierarchy configurations for external review.
• The Refactor Bridge (Exporter ➔ Replacer): Stage your obsolete scripts in the Exporter. Once you have rewritten them externally, click Stage for Batch Replacer. The coordinator automatically grabs all actively included scripts and injects them into the left side of the Batch Replacer sandbox, preparing the outdated assets for a project-wide swap without requiring you to manually locate them again.
• The Diagnostics Bridge (Replacer ➔ Exporter): If a Batch Replacement fails due to a corrupted serialized file or an OS-level file lock, the suite generates a critical error log. Clicking Export Errors instantly identifies the specific physical files that failed and adds them to the Exporter’s queue. It simultaneously injects the technical error log into the scratchpad, allowing you to easily copy the exact payload required to diagnose why the structural modification failed.

Expand Your Pipeline

Consider exploring the rest of the Veridian ecosystem on the Unity Asset Store:

Noise Texture Generator: Procedural PBR Baker

A procedural texture baker powered by the Burst Compiler. Blend Voronoi, FBM, and SDF math to algorithmically generate and bake seamlessly tiling PBR materials without leaving the Unity Editor.

Scene Object Replacer (Free)

Swap thousands of assets without freezing the Editor. A high-performance tool for replacing Scene Objects, Materials, and Terrain details. Includes weighted randomization and advanced filtering.