Designing New Maps, Preserving Old Ones: A Guide to Version Control for Creative Projects

Designing New Maps, Preserving Old Ones: Version Control for Creative Projects (Using Arc Raiders as a Case Study)

Hook: You’re juggling creative deadlines, shifting priorities, and the pressure to ship fresh content — yet every time you replace an old map or design, you lose lessons that could have made the next version faster, smarter, and less risky. That friction is exactly why smart teams treat maps and creative assets like software: with version control, archival practices, and a plan for iteration history.

The moment: Arc Raiders, maps arriving in 2026 — and why the old ones matter

In early 2026 Embark Studios confirmed that Arc Raiders will receive "multiple maps" across a range of sizes and gameplay types, including some smaller arenas and some even larger expanses than existing levels. That announcement (covered by GamesRadar and Polygon) sparked a debate among players and designers: should developers aggressively replace old maps with new ones, or keep earlier iterations live and accessible?

Design lead Virgil Watkins told GamesRadar the team plans maps across a spectrum of size — but that shouldn't mean leaving older maps behind.

That debate illustrates an essential product and research principle: iteration history is data. Old maps are not just sentimental artifacts — they're a record of player behavior, balance decisions, technical constraints, and creative choices. Treating them as disposable loses institutional memory and increases risk.

Why preserve prior iterations? The product-level benefits

Before we get tactical, here’s why every creative team should embed archival thinking into their design workflow.

• Learning and post-mortems: Old iterations reveal design hypotheses and whether they succeeded. If a corridor change reduced chokepoint grief but increased camping, the prior version helps tell that story.
• Rollback & risk mitigation: Live games need fast recovery. Having a tagged, deployable previous map version cuts rollback time from hours to minutes.
• Telemetry baselines: Compare engagement metrics across iterations. A new map might increase session length but harm team cohesion — you’ll only know if you can correlate versions to metrics.
• Community & modding: Players, creators, and academics value old maps for nostalgia and research. Preserved assets extend community lifespan and player retention.
• Legal & compliance: User-generated content or licensed assets may carry requirements for retention or provenance that archival practice satisfies.

2026 trends that change the game for archival and version control

Late 2025 and early 2026 introduced several developments you should plan for:

• AI-assisted diffs for binaries: Tools now offer visual and semantic diffs for scene files and textures, making binary comparison practical.
• Cloud-native asset registries: Asset stores integrated with CI/CD pipelines give teams automated provenance and distribution of map bundles.
• Edge delivery and hot swaps: Live build pushes can swap map variants server-side without client patches, so archive metadata must track runtime dependencies.
• Hybrid storage economics: Cold storage (S3 Glacier, Backblaze B2 with lifecycle rules) plus on-prem Perforce or Git LFS for active branches is the standard cost-performance mix.

Core version control and archival primitives for creative projects

Think of these as the foundation stones. Adopt them early; retrofit if necessary.

1. Use the right VCS for the job

Not all version control systems are equal for large binaries and game assets.

• Perforce Helix Core: Industry standard for large binaries, granular file locking, and strong performance for large teams. Ideal for AAA-style map assets.
• Plastic SCM: Popular in 2026 for its strong branching for artists and graphical diffing for Unity/Unreal assets.
• Git + Git LFS: Good for indie teams or when code and small assets dominate. Combine with external asset registries for large scene files.
• Hybrid approaches: Code in Git, large art and map bundles in Perforce or a cloud asset registry. Use CI to compose builds.

2. Branching & release strategy for map development

Maps are products. Treat each map or map update as a feature with its own branch lifecycle.

• Trunk (main): Deployable live build. Only QA-tested releases are merged here.
• Feature branches: One per new map or major tweak. Name: map/-v2.
• Release branches: For preparing a group of maps or seasonal drops: release/summer2026-maps.
• Hotfix branches: For immediate rollbacks and fixes to live maps: hotfix/-balance.

3. Tagging & semantic versions

Tags are an archival breadcrumb trail.

• Tag deployed maps with semantic versions and metadata: v1.3-map-stella-montis+build5678.
• Include engine version, asset bundle hash, and release notes in tag metadata.

4. Asset snapshots & canonical exports

Save canonical, engine-agnostic exports alongside engine-specific source files.

• Scene exports: glTF, USD, or FBX for geometry and transforms.
• Textures: lossless PNG/TGA and fingerprinted compressed versions for runtime.
• Runtime builds: a map-specific build or server bundle you can redeploy to reproduce player experience.

5. Metadata, provenance & checksums

Archival value is in metadata.

• Save: author, timestamp, tool versions (Unity/Unreal), third-party plugin versions, and validation logs.
• Store checksums (SHA-256) for every file to ensure integrity over time.

Practical, actionable archival playbook

Here’s a checklist you can implement in the next sprint. These steps scale from solo creators to studios.

1. Define what you archive.
   • Minimum: scene source, asset references, runtime build, telemetry snapshot, and release notes.
   • Optional: playtest videos, designer notes, AI-generated content seeds.
2. Automate exports.

   Implement CI/CD pipeline steps to produce canonical exports whenever a feature branch merges to release or trunk.

   • Example (pseudo): on merge -> run export_scene.sh -> produce glTF + runtime bundle -> push to asset-registry + sign with SHA-256.
3. Implement tiered storage.

   Hot (active branches) in Perforce/Plastic, warm in Git LFS or cloud object storage for recent releases, cold in Glacier or Backblaze for older snapshots.

4. Preserve a deployable snapshot.

   Each archived map should include everything needed to run it exactly as players experienced: server configs, AI nav meshes, and matchmaking settings.

5. Maintain an iteration changelog.

   At every archived version, include human-readable release notes and a machine-readable changelog (JSON) that lists diffs, authors, and test passes.

6. Schedule rediscovery reviews.

   Quarterly or biannual "map archaeology" reviews to extract lessons for future designs. These transform archives into learning assets.

7. Protect legal & user data boundaries.

   If telemetry contains PII, anonymize before archival or apply retention windows aligned with policy.

Example workflows: indie vs. studio

Indie (Unity or Godot, small team)

1. Code in GitHub, map scenes in Git LFS.
2. On release: CI job exports glTF + build, uploads bundles to S3, tags release in Git with metadata.
3. Long-term: lifecycle rule moves older releases to Glacier after 90 days.

Mid-size / Studio (Perforce + Plastic hybrid)

1. Artists and designers check assets into Perforce; code remains in Git.
2. Feature branches per map in Perforce; merges to main create an automated build pipeline that generates runtime bundles and telemetry snapshots.
3. Artifacts and signed metadata are pushed to an asset registry (cloud-native) and a cold archive bucket. CI attaches tags and release notes and increments an iteration history database.

Keeping iteration history useful: analytics, A/B testing, and community signals

Archival is only useful if you connect it to signals.

• Telemetry snapshots: Export key metrics (win rate by spawn point, average route choices, engagement heatmaps) tied to specific map versions.
• A/B experiments: Use archived versions as control or variant arms in live experiments; this preserves contextual integrity.
• Community-sourced variants: Allow modders or map-makers access to historic maps for remixing. This reduces churn and creates long-term value.

When to prune — and how to do it safely

Not every file needs infinite retention. Pruning is part of a healthy archival policy — as long as you follow safe practices.

• Keep at least N full deployable snapshots for the last X seasons (e.g., 12 months or 6 releases).
• Prune intermediate working files but keep canonical exports and the build used in production.
• Always store the provenance metadata and checksums even when removing raw intermediates.
• Use immutable storage and WORM policies for legally required artifacts.

Tooling & integrations recommended in 2026

Here’s a concise toolbox for teams in 2026. Choose based on team size and budget.

• Perforce Helix Core — best-in-class for binary-heavy game projects; file locking and performance for large teams.
• Plastic SCM — excellent branching and visual diffs for Unity/Unreal; artist-friendly UI.
• Git + Git LFS — lightweight, good when code dominates; pair with cloud asset registries.
• Cloud object storage (S3, Backblaze B2) with lifecycle rules — for automated warm-to-cold tiering.
• CI/CD (GitHub Actions, GitLab CI, TeamCity) — to automate exports, build artifacts, and attach metadata.
• Asset registries — cloud-native registries that store asset bundles with immutable metadata (2026 trend: AI-enabled registries that auto-detect conflicting dependencies).
• Checksum & integrity tools — automated SHA-256 checks on ingest and periodic integrity audits.
• AI-assisted binary diffing — emerging tools that produce visual diffs for scenes and textures, reducing blind spots in design reviews.

Case vignette: What Embark Studios gains by keeping older Arc Raiders maps

Imagine Embark ships grander maps in 2026. If they keep the earlier five locales accessible and archived with full iteration history:

• Designers can correlate how map scale affected player navigation patterns, informing future grand designs.
• Community creators can remix beloved maps, keeping veteran players engaged while new maps attract newcomers.
• Analytics teams can mine long-term trends: did smaller maps increase match intensity? Did a corridor tweak change role composition?
• Ops can roll back to a known-good map version if a new map introduces unexpected server load.

Quick templates you can copy this week

Branch naming

map/stellamontis-v2-feature | release/summer2026-maps | hotfix/bluegate-balance

Tag metadata JSON (example)

{
  "tag": "v2.0-map-stella-montis",
  "engine": "Unity 2024.3.8f",
  "assetBundleHash": "sha256:abcd...",
  "deployedAt": "2026-01-10T14:23:00Z",
  "authors": ["LeadDesignerA","ArtistB"],
  "telemetrySnapshotId": "telemetry-20260110-5678",
  "notes": "Reduced central corridor width; added flank route to reduce camping"
}

Final checklist: start preserving smartly

• Choose Perforce or Plastic if you work with large binary maps; consider hybrid Git workflows for code.
• Automate scene exports and runtime builds on merge to release or trunk.
• Attach machine-readable metadata, checksums, and human release notes to every archived version.
• Store telemetry snapshots and tie them to specific map tags for comparative analysis.
• Schedule periodic reviews to extract lessons and convert archives into actionable design guidance.

Parting thought — why old maps are a team’s smartest asset

Replacing maps is thrilling. Designing new spaces keeps players engaged and drives growth. But every discarded iteration is a missed research opportunity. Treat your maps like code: track them, tag them, and archive them with the same rigor you use for production releases. When Embark expands Arc Raiders this year, players will welcome new battlegrounds — and developers who keep earlier maps will gain the rare advantage of memory: the empirical record of what worked, what failed, and why.

Call to action

If you design maps, run a small studio, or lead product for a creative project, start small today: add one canonical export and one metadata tag to your next merge. If you want a checklist you can paste into your repo or Perforce job spec, sign up for our free template pack and a step-by-step CI example tuned for Unity and Perforce. Preserve history deliberately — your future iterations will thank you.

Related Reading

• Weekend Mountain Living for Dubai Expats: Best Towns for Ski and Snow Access
• Prefab Trail: Self-Guided Road Trip Stops with Modern Modular Stays
• De-escalation Scripts for Editors: Two Phrases That Save Submissions
• Email List Hygiene After Gmail Changes: A Step-by-Step Subscriber Migration Campaign
• Scale Up Your Homemade Frozen Fish Food: From Kitchen Batches to Community Orders