Recuperar 50-100 GB: Guía Completa de Limpieza de Disco para Desarrolladores .NET, Juegos y Escritorio

Todo desarrollador de software y videojuegos en Windows se enfrenta tarde o temprano a esa fatídica mañana: enciendes tu estación de trabajo, abres tu IDE y, de repente, Windows lanza una advertencia—a tu disco del sistema le quedan menos de 2 GB de espacio libre en un SSD NVMe de 1 TB.

No has descargado películas gigantes. No has instalado nuevos juegos de 100 GB. ¿A dónde se fue todo el almacenamiento?

Como desarrollador de juegos indie y aplicaciones de escritorio multiplataforma con .NET 8/9, MonoGame, Android / Móvil y Windows Application Packaging (MSIX/WAP para Microsoft Store), investigué recientemente esta silenciosa crisis de almacenamiento. Al ejecutar un escaneo automatizado en mis repositorios de proyectos, descubrí que más de 68 GB estaban ocupados por artefactos de compilación totalmente prescindibles, paquetes antiguos de publicación en tiendas y cachés globales.

En esta guía, desglosamos las razones arquitectónicas por las cuales las herramientas modernas consumen tanto espacio, explicamos por qué purgar estas carpetas es 100% seguro y compartimos una herramienta en PowerShell y Batch lista para copiar y pegar en cualquier proyecto para recuperar decenas de gigabytes al instante.

---

1. La Anatomía del Desperdicio de Disco en Desarrollo

¿A dónde va todo el espacio? Al compilar soluciones multiplataforma que apuntan a Escritorio, Móvil (Android) y Microsoft Store, los compiladores duplican binarios intermedios y recursos en cada etapa.

flowchart TD
    subgraph "Tu Área de Proyectos"
        Code["Código Fuente (.cs, .xaml, .json)\n(Protegido - Pocos MBs)"]
        Assets["Recursos Originales (PNG, OGG, Shaders)\n(Protegido)"]
        Git["Historial .git\n(Protegido)"]
        
        BinObj["Carpetas bin y obj\n(DLLs intermedias, símbolos, copias)\n[30 - 60 GB]"]
        AppPackages["WAP / MSIX AppPackages\n(Histórico .msixbundle, .msixupload)\n[5 - 20 GB]"]
    end

    subgraph "Cachés del Sistema y Globales"
        NuGet["%USERPROFILE%\\.nuget\\packages\n(Caché Global de Paquetes)\n[10 - 20 GB]"]
        Temp["%LOCALAPPDATA%\\Temp\n(Archivos temporales del compilador)\n[3 - 10 GB]"]
    end

    style BinObj fill:#ff6b6b,stroke:#c92a2a,stroke-width:2px,color:#fff
    style AppPackages fill:#ff6b6b,stroke:#c92a2a,stroke-width:2px,color:#fff
    style NuGet fill:#ff922b,stroke:#d9480f,stroke-width:2px,color:#fff
    style Temp fill:#ff922b,stroke:#d9480f,stroke-width:2px,color:#fff

Culpable A: Carpetas bin y obj (30 - 60+ GB)

Cada proyecto de C# genera dos carpetas durante la compilación:

• obj/ (Salida Intermedia): Guarda estados de compilación incremental, archivos generados por Source Generators e intermediarios específicos de cada plataforma. En proyectos multiplataforma, las salidas intermedias de Android pueden inflarse de 3 a 6 GB por proyecto.
• bin/ (Salida Binaria): Contiene los ensamblados finales, dependencias y todos los recursos copiados mediante <CopyToOutputDirectory>. Si 10 proyectos hacen referencia a una carpeta compartida de 500 MB de contenido de juego, ese contenido se duplica 10 veces, desperdiciando 5 GB en una sola solución.

Culpable B: Carpetas AppPackages de Microsoft Store (5 - 20+ GB)

Si publicas juegos o aplicaciones en la Microsoft Store usando proyectos WAP, Visual Studio genera la carpeta AppPackages:

• Cada versión crea un .msixbundle completo, un archivo .msixupload con símbolos PDB completos para telemetría de fallos y carpetas de prueba locales.
• Un solo paquete pesa entre 800 MB y 2.5 GB. Si compilas 10 versiones de prueba o parches, Visual Studio nunca elimina las versiones antiguas de forma automática.

Culpable C: Caché Global de NuGet (10 - 20+ GB)

En %USERPROFILE%\.nuget\packages, este directorio almacena cada versión de cada paquete descargado en tu sistema. Si una librería se actualiza de 12.0.1 a 12.0.2, la versión antigua permanece indefinidamente.

Culpable D: Archivos Temporales de Windows (Temp) (3 - 10 GB)

Durante los procesos de compilación y compresión de paquetes, Visual Studio y MSBuild extraen herramientas y archivos temporales en %LOCALAPPDATA%\Temp, acumulando miles de archivos huérfanos.

---

2. Garantía de Seguridad: ¿Por qué es 100% Seguro?

Es natural que los desarrolladores sean prudentes al borrar archivos. La regla de seguridad es inequívoca:

Protegido (NUNCA se toca)	Seguro de Eliminar (100% Desechable)
Código Fuente: .cs, .xaml, .cpp, .h, .ts, .json	Archivos objeto del compilador (obj/)
Definiciones de Proyecto: .sln, .csproj, .wapproj	Ensamblados compilados y dependencias (bin/)
Repositorios Git: Carpeta .git/, ramas e historial	Paquetes antiguos de la tienda (AppPackages/)
Recursos Originales: Texturas (.png), Audio (.ogg), Shaders	Paquetes NuGet descargados (.nuget\packages)
Certificados y Asociaciones: .pfx, StoreAssociation.xml	Archivos temporales de trabajo (%LOCALAPPDATA%\Temp)

¿Qué ocurre al reabrir Visual Studio?
Al abrir el proyecto y presionar Build o Rebuild, Visual Studio y el SDK de .NET regeneran las carpetas obj/ y bin/ automáticamente a partir de tu código fuente. NuGet descarga los paquetes faltantes durante la restauración. No pierdes absolutamente nada.

---

3. La Solución Automatizada: Script de Limpieza en Un Clic

En lugar de navegar manualmente por cientos de carpetas, creamos un motor en PowerShell con un ejecutable Batch listo para usar.

Motor de Limpieza en PowerShell (Clean-DevDiskSpace.ps1)

Guarda este script en _tools/Clean-DevDiskSpace.ps1 dentro de tu área de proyectos:

<#
.SYNOPSIS
    Herramienta Universal de Limpieza de Espacio para Desarrolladores.
#>
[CmdletBinding()]
param (
    [switch]$Force,
    [switch]$ScanOnly,
    [switch]$SkipNuget,
    [switch]$SkipTemp,
    [string]$RootPath = ""
)

if ([string]::IsNullOrWhiteSpace($RootPath)) {
    if ($PSScriptRoot) { $RootPath = (Join-Path $PSScriptRoot "..") } else { $RootPath = Get-Location }
}
$resolvedRoot = (Resolve-Path $RootPath -ErrorAction SilentlyContinue).Path

if ([string]::IsNullOrWhiteSpace($resolvedRoot) -or $resolvedRoot -in @("C:\", "C:", "\", "/")) {
    Write-Host "BLOQUEO DE SEGURIDAD: ¡La ruta es la raíz del sistema o no es válida!" -ForegroundColor Red
    exit 1
}

$Host.UI.RawUI.WindowTitle = "Limpieza de Disco para Desarrolladores"
Write-Host "Espacio de trabajo objetivo: $resolvedRoot" -ForegroundColor Yellow

$systemDrive = Get-PSDrive -Name C
$freeGBBefore = [math]::Round($systemDrive.Free / 1GB, 2)
Write-Host "`nEspacio libre actual en C: $freeGBBefore GB`n" -ForegroundColor Yellow

$binObjDirs = Get-ChildItem -Path $resolvedRoot -Recurse -Directory -Force -ErrorAction SilentlyContinue |
              Where-Object { $_.Name -in @('bin', 'obj') }
$binObjTotalBytes = ($binObjDirs | ForEach-Object { (Get-ChildItem -Path $_.FullName -Recurse -File -Force -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum } | Measure-Object -Sum).Sum
$binObjGB = [math]::Round($binObjTotalBytes / 1GB, 2)

$appPackageDirs = Get-ChildItem -Path $resolvedRoot -Recurse -Directory -Filter "AppPackages" -Force -ErrorAction SilentlyContinue
$storeTotalBytes = ($appPackageDirs | ForEach-Object { (Get-ChildItem -Path $_.FullName -Recurse -File -Force -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum } | Measure-Object -Sum).Sum
$storeGB = [math]::Round($storeTotalBytes / 1GB, 2)

$tempPath = [System.IO.Path]::GetTempPath()
$tempBytes = (Get-ChildItem -Path $tempPath -Recurse -File -Force -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum
$tempGB = if (-not $SkipTemp) { [math]::Round($tempBytes / 1GB, 2) } else { 0 }

$nugetCachePath = "$env:USERPROFILE\.nuget\packages"
$nugetBytes = (Get-ChildItem -Path $nugetCachePath -Recurse -File -Force -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum
$nugetGB = if (-not $SkipNuget) { [math]::Round($nugetBytes / 1GB, 2) } else { 0 }

$totalReclaimableGB = [math]::Round($binObjGB + $storeGB + $tempGB + $nugetGB, 2)

Write-Host "Ahorro total estimado: $totalReclaimableGB GB" -ForegroundColor Cyan

if ($ScanOnly) { Write-Host "Modo escaneo finalizado." -ForegroundColor Yellow; return }
if (-not $Force) {
    $prompt = Read-Host "¿Deseas iniciar la limpieza segura? (S/N)"
    if ($prompt -notin @('S', 's', 'Y', 'y', 'Si', 'si')) { return }
}

# Eliminación segura
$binObjDirs | ForEach-Object { try { Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue } catch {} }
$appPackageDirs | ForEach-Object { try { Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue } catch {} }
if (-not $SkipTemp) { Get-ChildItem -Path $tempPath -Force -ErrorAction SilentlyContinue | ForEach-Object { try { Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue } catch {} } }
if (-not $SkipNuget) { try { $null = dotnet nuget locals all --clear 2>&1 } catch {} }

$systemDriveAfter = Get-PSDrive -Name C
$freeGBAfter = [math]::Round($systemDriveAfter.Free / 1GB, 2)
$freedTotal = [math]::Round($freeGBAfter - $freeGBBefore, 2)
Write-Host "`n¡LIMPIEZA COMPLETADA! Espacio recuperado: +$freedTotal GB" -ForegroundColor Green

Iniciador Batch (clean-disk-space.bat)

Coloca este archivo en la carpeta principal de tus proyectos:

@echo off
setlocal
title Limpieza de Disco de Proyectos
cd /d "%~dp0"
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0_tools\Clean-DevDiskSpace.ps1" %*
pause

---

4. Resultados Reales: De 1.35 GB a 53.80 GB

En una prueba real en un entorno con proyectos móviles, de escritorio y motores de videojuegos:

• Espacio Libre Inicial: 1.35 GB (Disco en alerta roja)
• Espacio Libre Final: 53.80 GB
• Espacio Neto Recuperado: +52.45 GB en menos de 3 minutos.

Todo el código fuente y las configuraciones permanecieron intactos. Al recompilar los proyectos activos, solo se generaron los archivos necesarios para la sesión de trabajo.

---

5. Buenas Prácticas de Mantenimiento

1. Borra AppPackages tras publicar: Cuando la tienda apruebe tu paquete .msixupload, elimina la carpeta local de paquetes generados.
2. Ejecuta una limpieza mensual: Un doble clic cada 30 días previene acumulaciones silenciosas de 50 GB.
3. Mantén al día tu .gitignore: Asegúrate de excluir siempre bin/, obj/ y AppPackages/ de tus repositorios.

---

Sobre Arar Games y Nuestros Juegos

Descubre nuestros juegos indie y conecta con nuestro estudio:

• 🌐 Sitio Web Oficial: https://www.mayhemcorporation.com

🎮 Nuestros Juegos

• Blocked: Pixel Panzer: Combate de tanques retro arcade con clima dinámico y jefes.
  Google Play (Android y PC)
• PaintTrek: Rompecabezas de colores vivos y acción de pintura de píxeles.
  Google Play | Microsoft Store (PC y Xbox)
• Space Dodger: Evasión espacial retro arcade de reflejos rápidos.
  Google Play

📱 Síguenos en Redes Sociales

• 🎵 TikTok: https://www.tiktok.com/@arargamesstudio
• 📸 Instagram: https://www.instagram.com/arargamesstudio
• 🐦 X (Twitter): https://x.com/arargamesstudio
• 📺 YouTube: https://www.youtube.com/@koreaaria
• 🧵 Threads: https://www.threads.net/@arargamesstudio
• 📘 Facebook: https://www.facebook.com/arargamesstudio