Introduction
If you build big codebases or game projects on Windows—Unreal Engine, Unity, Node/TypeScript monorepos, Chromium, .NET—storage I/O is one of the biggest bottlenecks. Microsoft’s Dev Drive is a developer‑focused storage volume built on ReFS with optional Microsoft Defender Antivirus Performance Mode to reduce scanning overhead. In theory, Dev Drive should speed up Git operations, package restores, asset imports, intermediate builds, and caches. In practice, does it actually help for Unreal and Unity? This guide explains the feature in plain language, shows you how to set it up correctly, and provides a repeatable test plan and benchmarks so you can measure gains on your own hardware.
What you’ll get:
- A deep overview of Dev Drive, ReFS, and Defender Performance Mode
- A step‑by‑step setup, including checks, commands, and safe settings
- A rigorous test plan for Unreal and Unity builds, editor workflows, and Git operations
- Troubleshooting for the most common issues
- Performance tips, recommended folder layouts, and best practices
Overview: What Dev Drive is and when it helps
-
What Dev Drive is
- A dedicated Windows 11 volume formatted with ReFS and tuned for development workloads
- Integrates with Microsoft Defender Antivirus to enable Defender Performance Mode on that volume, reducing real‑time scanning overhead on common dev file patterns (node_modules, Git objects, build intermediates, asset caches)
- Available via Settings (GUI) or PowerShell
-
Why ReFS matters for dev workloads
- Modern metadata handling and better parallel I/O patterns for many small files
- Optional integrity streams (checksums) that you can disable for hot caches to reduce CPU and write amp
- Designed for resiliency; distinct from NTFS (not a boot volume)
-
Where it helps most
- Git and monorepo workflows: cloning, fetch, checkout, status, large file trees
- Package manager installs/restores: npm/pnpm/yarn, NuGet, pip, etc.
- Build toolchains: Unreal Build Tool (UBT), Unity Asset/Library generation, IL2CPP, CMake/Ninja/MSBuild
- Caches: Unreal DerivedDataCache (DDC), Unity Library/Cache, shader caches, intermediate object/output folders
- Editor cold starts and import passes: first open of a project, massive directory enumerations
-
Where it may not help as much
- CPU‑bound compiles with warm caches
- Workloads dominated by GPU or network I/O
- Scenarios where a third‑party AV replaces Defender (you lose Performance Mode, but Dev Drive still functions)
Key idea: Even if your disk is already fast (NVMe), minimizing antivirus scanning overhead and filesystem metadata costs can trim seconds to minutes from repetitive tasks—especially on large projects.
Quick Reference Table
| Command | Purpose | Example Output |
|---|---|---|
| winver | Show Windows version/build (ensure Dev Drive support) | Version 23H2 (OS Build 22631.XXXX) |
| Get-ComputerInfo | Programmatic OS check | OsName: Microsoft Windows 11 Pro |
| Get-Command DevDrive | Discover Dev Drive PowerShell cmdlets available on your build | CommandType Name Version Source: Function New-DevDriveVolume … |
| New-DevDriveVolume -DriveLetter E -Size 300GB -Label Dev | Create a Dev Drive via PowerShell (variant 1) | New ReFS volume E: Dev successfully created |
| New-DevDrive -DriveLetter E -Size 300GB -Label Dev | Create a Dev Drive via PowerShell (variant 2) | Dev Drive E: created |
| fsutil fsinfo volumeinfo E: | Verify filesystem and flags | File System Name : ReFS; Volume Name : Dev; … |
| fsutil fsinfo refsinfo E: | Show ReFS details | ReFS Version : 3.x; Bytes Per Cluster : 4096 |
| Get-MpComputerStatus | Validate Defender is active | RealTimeProtectionEnabled : True |
| Set-FileIntegrity -FileName E:\DDC -Enable $false | Disable ReFS integrity streams for a hot cache folder | (no output on success) |
| git config –global core.untrackedCache true | Speed up git status in large repos | (no output on success) |
| “%ProgramFiles%\Epic Games\UE_5.3\Engine\Build\BatchFiles\RunUAT.bat” BuildCookRun … | Automation for Unreal test | UATHelper: Packaging (Windows (64-bit)): … |
| “c:\Program Files\Unity\Hub\Editor\2022.3.XXf1\Editor\Unity.exe” -batchmode … | Headless Unity build/import | Build completed with a result of ‘Succeeded’ |
Setup and Key Concepts
Prerequisites and support
- OS: Windows 11 22H2 (Moment 3) or later; 23H2 recommended for best Dev Drive experience
- Storage: Enough free space to carve a new partition/volume (50 GB minimum recommended; 200 GB+ common for UE/Unity)
- Antivirus: Microsoft Defender Antivirus in active mode for Defender Performance Mode; if you run third‑party AV, Dev Drive works but you don’t get Performance Mode
- Rights: Administrator privileges to create and format volumes
- Developer Mode: Turn on Developer Mode in Settings if prompted during Dev Drive creation
How Dev Drive works with Defender
- When Microsoft Defender Antivirus is the active AV and real‑time protection is on, volumes flagged as Dev Drive automatically use Performance Mode, reducing scanning overhead on developer workloads while maintaining security
- You do not need to disable Defender or add broad exclusions; Performance Mode is automatic for the Dev Drive volume
ReFS integrity streams
- ReFS can maintain per‑file checksums (“integrity streams”)
- For large, frequently changing caches (e.g., Unity Library, Unreal DDC), disable integrity streams to reduce write overhead: use the PowerShell cmdlet Set-FileIntegrity
- Keep integrity streams on for critical or archival data; consider disabling only on hot caches and intermediates
Step-by-Step Guide
- Confirm OS and features
-
GUI: Press Win+R -> winver -> confirm Windows 11 23H2+ preferred
-
PowerShell:
Get-ComputerInfo | Select-Object OsName, OsVersion, OsBuildNumber
Get-Command DevDrive -ErrorAction SilentlyContinueIf no Dev Drive cmdlets appear, create the volume via Settings or standard partitioning then format as ReFS.
- Create a Dev Drive (GUI method)
- Settings -> System -> Storage -> Advanced storage settings -> Disks & volumes
- Click Create Dev Drive
- Choose size (e.g., 300 GB), assign a drive letter (e.g., E:) and label (e.g., Dev)
- Finish and let Windows format as ReFS and flag as Dev Drive
- Create a Dev Drive (PowerShell method)
Note: Depending on your Windows build, you may have New-DevDriveVolume or New-DevDrive. Check with Get-Command.
-
Variant 1 (New-DevDriveVolume):
New-DevDriveVolume -DriveLetter E -Size 300GB -Label “Dev”
-
Variant 2 (New-DevDrive):
New-DevDrive -DriveLetter E -Size 300GB -Label “Dev”
-
If neither cmdlet exists, create the partition normally and format as ReFS:
Get-Disk | Where-Object IsSystem -eq $false | Sort-Object Number
Contents showChoose your disk number carefully
Create partition (example: free space on Disk 1)
New-Partition -DiskNumber 1 -Size 300GB -DriveLetter E
Format-Volume -DriveLetter E -FileSystem ReFS -NewFileSystemLabel “Dev” -Force
- Verify the volume and ReFS details
-
Confirm file system and flags:
fsutil fsinfo volumeinfo E:
fsutil fsinfo refsinfo E:Example (abridged):
- File System Name : ReFS
- Volume Name : Dev
- ReFS Version : 3.9
- Ensure Defender is active and Performance Mode eligible
-
Check Defender status:
Get-MpComputerStatus | Select-Object AMServiceEnabled, RealTimeProtectionEnabled, AntispywareEnabled
All should be True for Microsoft Defender to be active.
-
Keep Real‑Time Protection enabled. If you use third‑party AV, note that Defender Performance Mode will not apply.
- Enable Windows long paths (recommended for deep project trees)
-
Registry (requires reboot):
New-ItemProperty -Path “HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem” `
-Name “LongPathsEnabled” -PropertyType DWord -Value 1 -Force -
Or Group Policy: Local Computer Policy -> Computer Configuration -> Administrative Templates -> System -> Filesystem -> Enable Win32 long paths
- Plan your folder layout on the Dev Drive
Recommended top-level structure on E:\
- E:\src\ (your Git repos: UE projects, Unity projects)
- E:\build\ (out-of-source builds, binaries)
- E:\caches\ue-ddc (Unreal DerivedDataCache)
- E:\caches\unity (Unity Library/Cache)
- E:\tools\ (aux tools, SDKs that are file‑heavy)
- Prepare Unreal Engine to use the Dev Drive
-
Move or set the Derived Data Cache to the Dev Drive:
-
Create E:\caches\ue-ddc
-
Disable integrity streams (hot cache):
Set-FileIntegrity -FileName “E:\caches\ue-ddc” -Enable $false
-
In UE Editor: Edit -> Editor Preferences -> Derived Data Cache
- Local DDC: E:\caches\ue-ddc\Local
- Shared DDC (optional): E:\caches\ue-ddc\Shared
-
-
Place the project and Intermediate/Saved folders on the Dev Drive (or redirect intermediates via UBT settings if you keep sources elsewhere)
-
Optional: For command line UAT runs, ensure project path, DDC, and staging are on E:
- Prepare Unity to use the Dev Drive
- Put the Unity project under E:\src\YourUnityProject
- Ensure the project’s Library folder lives on the Dev Drive (default if the project lives there)
- Optional: Unity Accelerator cache path -> point to E:\caches\unity\accelerator
- For IL2CPP temp/artifact paths, keep project and build output on E:\build\
- Apply Git performance settings (especially for large repos)
Run in PowerShell once (global):
git config –global core.untrackedCache true
git config –global core.fsmonitor true
git config –global feature.manyFiles true
git config –global gc.writeCommitGraph true
git config –global commitGraph.generationVersion 2
Note: fsmonitor relies on a platform file watcher; if you see issues, disable it per‑repo.
- Optional: Disable ReFS integrity streams on hot folders
For write‑heavy, rapidly changing paths:
Set-FileIntegrity -FileName “E:\src\YourRepo\Intermediate” -Enable $false
Set-FileIntegrity -FileName “E:\src\YourUnityProject\Library” -Enable $false
Keep integrity streams enabled for source code and important assets.
- Benchmark methods and example commands
General timing with PowerShell:
-
Measure any command:
Measure-Command { git status } | Select-Object TotalMilliseconds
-
Repeat 3–5 times and average; use warm and cold cache runs.
Git tests:
-
Clone large repo to Dev Drive:
Measure-Command { git clone https://your/repo.git E:\src\repo-dev }
-
Compare to an NTFS volume clone (baseline)
-
Checkout test:
Set-Location E:\src\repo-dev
Measure-Command { git checkout some-large-branch }
Measure-Command { git status }
Unreal tests (UE 5.x):
-
UAT BuildCookRun example:
“%ProgramFiles%\Epic Games\UE_5.3\Engine\Build\BatchFiles\RunUAT.bat”
BuildCookRun -project="E:\src\UE\Lyra\Lyra.uproject" -noP4 -platform=Win64
-clientconfig=Development -cook -build -stage -pak -archive `
-archivedirectory=”E:\build\Lyra” -
Measure full cook+build:
Measure-Command {
& “$env:ProgramFiles\Epic Games\UE_5.3\Engine\Build\BatchFiles\RunUAT.bat”BuildCookRun -project="E:\src\UE\Lyra\Lyra.uproject" -noP4 -platform=Win64
-clientconfig=Development -cook -build -stage -pak -archive `
-archivedirectory=”E:\build\Lyra”
} | Select-Object TotalMinutes -
Incremental C++ compile (small change):
- Touch a cpp, run UBT from command line, measure again
-
DDC warm vs cold:
- Delete E:\caches\ue-ddc\Local to simulate cold DDC and re-run
Unity tests (2021 LTS / 2022 LTS / 2023 LTS):
-
First open/import (Library creation):
“C:\Program Files\Unity\Hub\Editor\2022.3.XXf1\Editor\Unity.exe”
-batchmode -nographics -projectPath "E:\src\Unity\BigProject"
-quit -logFile “E:\build\logs\unity_import.log” -
Build Windows player (Mono or IL2CPP):
-
In C#, create a static build method (e.g., BuildTools.PerformBuild)
-
Run:
“C:\Program Files\Unity\Hub\Editor\2022.3.XXf1\Editor\Unity.exe”
-batchmode -nographics -projectPath "E:\src\Unity\BigProject"
-executeMethod BuildTools.PerformBuild `
-quit -logFile “E:\build\logs\unity_build.log”
-
-
Measure using PowerShell:
Measure-Command {
& “C:\Program Files\Unity\Hub\Editor\2022.3.XXf1\Editor\Unity.exe”-batchmode -nographics -projectPath "E:\src\Unity\BigProject" -quit
-logFile “E:\build\logs\unity_import.log”
} | Select-Object TotalMinutes
Node/Package restore sampling (optional):
Set-Location E:\src\repo-dev
Measure-Command { npm ci } | Select-Object TotalSeconds
- Interpreting your results
- Always compare apples to apples: same machine, same power plan (High performance), same repo state, same editor version, same target, same antivirus configuration
- Run at least three iterations of each test; discard outliers and average
- Watch MsMpEng.exe CPU during runs (Task Manager or Performance Monitor). With Defender Performance Mode on a Dev Drive, MsMpEng CPU should be notably lower during heavy file churn compared to an NTFS baseline
- Optional: Useful fsutil and system queries
ReFS and volume info:
fsutil fsinfo volumeinfo E:
fsutil fsinfo refsinfo E:
Check path length support:
reg query HKLM\SYSTEM\CurrentControlSet\Control\FileSystem /v LongPathsEnabled
Ensure Defender real-time protection is enabled:
Get-MpComputerStatus | Select-Object RealTimeProtectionEnabled
Troubleshooting
-
Cannot create Dev Drive (button greyed out or PowerShell cmdlet missing)
- Ensure Windows 11 22H2/23H2 with latest cumulative updates
- Use Settings -> Disks & volumes -> Create Dev Drive instead of PowerShell
- If PowerShell cmdlets are missing, create a standard partition and format as ReFS; Windows should still recognize it for Dev Drive scenarios
- Verify free space and that the drive is a fixed disk (removable media may be blocked)
-
“Trust not satisfied” or similar prompt
- Turn on Developer Mode: Settings -> System -> For developers -> Developer Mode
- Retry creating the Dev Drive
-
Defender Performance Mode seemingly not active
-
Check that Microsoft Defender Antivirus is the active AV and Real‑Time Protection is enabled:
Get-MpComputerStatus | Select RealTimeProtectionEnabled, AMServiceEnabled
-
If you use third‑party AV, Performance Mode will not apply
-
Update Windows Security definitions and reboot
-
-
Slow git status even on Dev Drive
-
Enable Git accelerations:
git config –global core.untrackedCache true
git config –global commitGraph.generationVersion 2
git maintenance start -
Consider sparse checkout or partial clone for huge repos
-
Verify Windows Search indexing is disabled on the repo (Folder Properties -> General -> Advanced -> uncheck “Allow files on this drive to have contents indexed” for the Dev Drive, or exclude the path in Indexing Options)
-
-
ReFS integrity streams causing higher CPU on caches
-
Disable integrity streams on hot cache folders:
Set-FileIntegrity -FileName “E:\src\Repo\Intermediate” -Enable $false
-
Leave integrity ON for source folders and important assets
-
-
Unreal/Unity paths too long or build fails with path issues
-
Ensure long paths are enabled:
New-ItemProperty -Path “HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem” `
-Name “LongPathsEnabled” -PropertyType DWord -Value 1 -Force -
Reboot after the change
-
-
“Access denied” or antivirus conflicts
- Do not disable antivirus globally; if necessary add targeted exclusions for per‑project Intermediate/Library folders since these are ephemeral
- Keep source and binaries scanned; use Defender Performance Mode as the default approach
Performance Tips & Best Practices
Recommended folder layout
- Keep source and builds together on the Dev Drive to maximize locality:
- E:\src\YourUEProject, E:\src\YourUnityProject
- E:\build\YourUEBuilds, E:\build\YourUnityBuilds
- E:\caches\ue-ddc, E:\caches\unity
- Avoid putting dev caches on system C: if it’s not NVMe or is capacity constrained
Defender and exclusions
- Let Defender Performance Mode do the heavy lifting on the Dev Drive
- If you still need exclusions, keep them narrow: specific Intermediate, DerivedDataCache, Library, or node_modules paths; avoid excluding entire drive letters
ReFS integrity streams strategy
-
Disable on high‑churn caches and intermediates for speed:
Set-FileIntegrity -FileName “E:\caches\ue-ddc” -Enable $false
Set-FileIntegrity -FileName “E:\src\Unity\BigProject\Library” -Enable $false -
Keep enabled for source code, third‑party SDKs, and archives
Indexing and search
- Disable Windows Search indexing on the Dev Drive or large repos:
- Drive Properties -> uncheck “Allow files on this drive to have contents indexed”
- Or Control Panel -> Indexing Options -> Modify -> uncheck Dev Drive paths
Git and repo hygiene
-
Use sparse checkout or partial clone for mega‑repos
-
Run git maintenance:
git maintenance start
git maintenance run –task=gc –task=commit-graph –task=prefetch -
Store Git temp and pack files on the Dev Drive (default if repo lives there)
Unreal Engine specifics
- Point the DDC to the Dev Drive; keep Intermediate and Saved on the Dev Drive
- Consider a Shared DDC on a fast local or network path if multiple team members rebuild content
- Use Ninja or FastBuild (if applicable) to reduce incremental build time; ensure its cache/temp live on E:
Unity specifics
- Keep the project and Library on the Dev Drive; this benefits initial import and reimports
- Unity Accelerator cache on the Dev Drive can speed up multi‑machine workflows
- IL2CPP output and temp directories on fast storage reduce build time
Benchmark discipline
- Baseline on NTFS vs Dev Drive with the same dataset
- Measure three times each, warm and cold cache scenarios
- Track MsMpEng.exe CPU and I/O counters in Performance Monitor
- Record OS build, Unity/UE versions, SSD model, and power plan with each result to make comparisons fair
Conclusion
For large Windows development workloads—especially Unreal and Unity—Dev Drive can deliver measurable improvements by combining ReFS characteristics with Defender Performance Mode to cut antivirus scanning overhead on high‑churn files. The biggest wins show up in Git operations, first‑time imports/builds, cache generation (Unreal DDC, Unity Library), and incremental changes that touch many small files. When you pair a well‑organized folder layout, selective ReFS integrity settings, and sane Git/engine configs, you can reclaim real minutes per build/test cycle. The steps in this guide are safe to apply and easy to roll back, and the test plan lets you validate the gains on your own hardware and projects with confidence.
FAQ
H4: Is Dev Drive only for Microsoft Defender users?
- Dev Drive works on any supported Windows 11 system, but Defender Performance Mode only activates if Microsoft Defender Antivirus is the active real‑time AV. If you use third‑party AV, the drive still functions as ReFS, but you won’t get Defender’s Dev Drive optimizations.
H4: Does ReFS hurt compatibility with tools that expect NTFS?
- Most developer tools work fine on ReFS. However, a few legacy utilities that rely on NTFS‑specific features (e.g., some EFS/compression behaviors) may not. Test critical workflows before fully migrating. Dev Drive is not bootable and is intended for data/projects.
H4: Should I disable antivirus or add blanket exclusions to speed things up?
- No. With Defender Performance Mode on a Dev Drive, you get reduced overhead without sacrificing protection. If needed, add narrow, targeted exclusions only for high‑churn intermediates (e.g., Unreal Intermediate, Unity Library), not entire repos or drive letters.
H4: How big should my Dev Drive be for Unreal or Unity?
- Start with 200–500 GB depending on your project size, DDC/Library footprint, and build artifacts. Unreal projects with large DDCs and cooked content can easily exceed 200 GB. You can add more Dev Drive volumes later if needed.
H4: How do I confirm the drive is really ReFS and recognized as Dev Drive?
-
Use:
fsutil fsinfo volumeinfo E:
fsutil fsinfo refsinfo E:Look for “File System Name : ReFS” and ReFS version. Ensure Defender is active via Get-MpComputerStatus. If you created it via Settings -> Create Dev Drive, Windows flags it appropriately; otherwise, formatting as ReFS on a dedicated volume is sufficient for most benefits.
