Migrate from Horizon Workrooms: practical alternatives and an IT migration checklist

Urgent: If your team used Horizon Workrooms, start this migration today

Meta announced that Horizon Workrooms and related commercial Quest offerings will be discontinued in February 2026. That means meeting rooms, avatars, shared whiteboards and any hosted collaboration state tied to Workrooms can stop working or become inaccessible. If your organization relied on Workrooms for workshops, onboarding, or recurring meetings, you need a practical migration plan that moves assets, users, and collaboration flows to sustainable alternatives.

Top‑level actions (do these in the next 7 days)

• Inventory what you have: rooms, recordings, avatars, 3D assets, invite links, SSO/enterprise integrations, and meeting calendars.
• Export everything you can now. Don’t wait for the shutdown date — exports may be rate limited or removed.
• Choose target platforms based on use cases: lightweight web rooms (Gather, Mozilla Hubs variants), enterprise immersive platforms (Microsoft Mesh integrations, Engage), or plain web apps (Miro, Figma + video call).
• Plan user provisioning and SSO/SCIM migration (SCIM/Okta/Azure AD) and test with a pilot team.
• Communicate a clear timeline to stakeholders and schedule training for the chosen alternatives.

Why this matters in 2026: trends that shaped the decision

By late 2025 the collaboration market continued shifting toward open web standards and hybrid workflows. WebXR and WebGPU have matured into reliable browser-based immersive experiences, and enterprises are favoring platforms that provide portability, strong security controls, and provable data export paths. Vendors who failed to deliver clear data portability and enterprise integration found adoption shrinking.

Meta’s decision to discontinue Workrooms is a reminder: viral adoption doesn't equal long-term enterprise reliability. For IT and dev teams, the takeaway is clear — prioritize platforms and workflows that minimize vendor lock‑in and emphasize automation, identity integrations, and exportable asset formats (.glb/.gltf, MP4, JSON).

Migration strategy overview

Split the migration into three parallel streams that map to how teams actually work:

1. Assets — 3D models, avatars, room layouts, whiteboards, recordings.
2. Users — accounts, SSO, role mappings, licenses.
3. Collaboration flows — recurring meetings, integrations (calendar, MDM, bots), training and templates.

Each stream has checkpoints: copy/export → validate → import → test → cutover. Below are detailed, actionable steps, examples, and scripts you can use or adapt.

1) Asset migration: export, convert and validate

What to export now

• Room metadata and layouts (if exportable)
• 3D assets and avatars (.glb, .gltf, .fbx where available)
• Whiteboard content (images, PDFs, text transcripts)
• Meeting recordings and chat logs (MP4, VTT/JSON)
• Shared files/links and pinned resources

Common export formats and best practices

• 3D models: Prefer glTF/GLB — it's compact and supported widely by Three.js, Babylon, A-Frame, Mozilla Hubs clones, and Frame-based platforms.
• Avatars: Export as GLB + separate JSON for rigging metadata if available.
• Recordings: MP4 for video, VTT or WebVTT for captions, and JSON for event logs.
• Whiteboards: Export as PNG/PDF and a machine-readable JSON if the vendor provides it (for reconstructing boards programmatically).

Batch converting GLTF/GLB — runnable example

Use Node.js and gltf-transform to normalize and compress GLB assets before importing into a new platform. This example shows a simple bulk convert + draco compress pipeline.

/* bulk-convert.js — requires: npm i @gltf-transform/core @gltf-transform/extensions @gltf-transform/functions gltf-pipeline axios */
const fs = require('fs');
const path = require('path');
const { NodeIO } = require('@gltf-transform/core');
const draco = require('@gltf-transform/functions').draco;

const inputDir = './exported-assets';
const outputDir = './normalized-assets';
if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir);

const io = new NodeIO();

async function processFile(file) {
  try {
    const doc = io.read(path.join(inputDir, file));
    await draco({ compressionLevel: 6 })(doc);
    io.write(path.join(outputDir, file.replace(/\.gltf?$/i, '.glb')), doc);
    console.log('Processed', file);
  } catch (e) {
    console.error('Failed', file, e.message);
  }
}

(async () => {
  const files = fs.readdirSync(inputDir).filter(f => /\.gltf?$|\.glb$/i.test(f));
  for (const f of files) await processFile(f);
})();

Annotate assets with a small JSON manifest so you can reimport and rebuild rooms automatically. Example manifest line:

{
  "assetId": "room-123-chair-01",
  "file": "chairs/chair01.glb",
  "license": "CC-BY-4.0",
  "author": "design-team@example.com"
}

Validating assets in a WebXR-friendly preview

Quick local preview using three.js and the GLTFLoader. Host on a web server and test on device browsers that support WebXR.

// index.html minimal snippet
<!doctype html>
<html>
<head><meta charset="utf-8"/><meta name="viewport" content="width=device-width,initial-scale=1"/></head>
<body>
<script type="module">
import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.156.0/build/three.module.js';
import { GLTFLoader } from 'https://cdn.jsdelivr.net/npm/three@0.156.0/examples/jsm/loaders/GLTFLoader.js';
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(70, innerWidth/innerHeight, 0.01, 1000);
const renderer = new THREE.WebGLRenderer({ antialias:true });
renderer.setSize(innerWidth, innerHeight); document.body.appendChild(renderer.domElement);
const loader = new GLTFLoader();
loader.load('/normalized-assets/chair01.glb', (gltf)=>{ scene.add(gltf.scene); });
camera.position.set(0,1.6,2);
function animate(){ requestAnimationFrame(animate); renderer.render(scene,camera); }
animate();
</script>
</body>
</html>

2) User migration and identity: plan SSO and provisioning

Users are the hardest part of migration. Plan for license reconciliation, SSO/SCIM provisioning, role mapping, and deprovisioning of hardware.

Inventory and export

• List of Workrooms users and their email identities (CSV).
• Mapping of admin roles and room owners.
• Device assignments (which Quest headsets are corporate-owned).

Bulk provisioning example (SCIM-like POST)

If your new platform supports SCIM, you can programmatically provision users. Example using Node.js + axios — replace endpoint and token with your target.

// scim-provision.js — npm i axios
const axios = require('axios');
const csv = `userName,displayName,emails\nalice@example.com,Alice,alice@example.com\n`;
const users = csv.trim().split('\n').slice(1).map(line => { const [userName, displayName, email] = line.split(','); return { userName, name: { givenName: displayName.split(' ')[0] }, emails: [{ value: email }] }; });

async function createUser(user){
  try{
    const res = await axios.post('https://new-platform.example.com/scim/v2/Users', user, { headers: { Authorization: 'Bearer YOUR_TOKEN', 'Content-Type': 'application/scim+json' } });
    console.log('Created', res.data.id);
  }catch(e){ console.error('Fail', user.userName, e.response ? e.response.data : e.message); }
}

(async ()=>{ for(const u of users) await createUser(u); })();

SSO mapping and license reconciliation

• Map Workrooms admins → new admins. Keep an audit trail (CSV).
• If purchasing new licenses, negotiate overlap window of 30–90 days to avoid service disruption.
• Plan device reassignments and EMM/MDM actions (wipe or repurpose headsets).

3) Collaboration flows: rebuild meetings, integrations, and templates

Not all platforms provide the same affordances. Decide which flows are critical and which can be simplified.

Classify collaboration flows

1. Essential synchronous: recurring all-hands, standups, workshops requiring spatial presence.
2. Optional synchronous: brainstorming rooms that can be replaced with Miro + Teams/Meet.
3. Asynchronous: recordings, shared whiteboards, design artifacts.

Recreate recurring rooms — checklist

• Export calendar invites; update location with new join link.
• Recreate room templates and pin important resources.
• Run pilot meetings and gather feedback from power users.

Integration stitch: calendars, bots, and automation

Preserve calendar integrations (Google Workspace, Exchange/Office365) and bots. Use the new platform’s webhook or REST API to replicate triggers (start recording, post notes, export whiteboard snapshots). For archiving transcripts, follow field-tested capture guides like the portable preservation lab.

Example: webhook to capture meeting end and export notes

// webhook-handler.js — npm i express axios body-parser
const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');
const app = express(); app.use(bodyParser.json());

app.post('/webhooks/meeting-ended', async (req,res)=>{
  const payload = req.body; // { meetingId, roomOwner, transcriptUrl }
  try{
    // Download transcript and save to your archive
    const transcript = await axios.get(payload.transcriptUrl, { responseType: 'text' });
    await axios.post('https://your-archive.example.com/api/save', { meetingId: payload.meetingId, transcript: transcript.data });
    res.sendStatus(200);
  }catch(e){ console.error(e); res.sendStatus(500); }
});

app.listen(3000); console.log('Listening on 3000');

Choosing alternatives: platform mapping (practical guide)

Pick a target by matching use cases. Below are generalized mappings — evaluate the latest vendor docs and test with your assets.

• Web-first lightweight (low friction): Gather-like experiences and web-based rooms. Pros: no headset required, easy onboarding. Good for regular meetings and social spaces.
• Enterprise immersive: Platforms focusing on security, SSO/SCIM, and admin controls. Best for companies that require device management and compliance.
• Hybrid stack: Combine standard tools (Zoom/Teams) + design spaces (Miro/Figma) + occasional VR sessions on an opt-in vendor. Reduces lock-in and supports diverse user hardware.

Evaluation checklist for vendor selection

• Data export guarantees and available APIs
• Identity integrations (SCIM, SAML, OIDC)
• Device management and remote wipe
• Encryption at rest and in transit; SOC/ISO certifications
• Pricing model and ability to thinly provision during overlap
• Support for GLB/gltf assets and automated import APIs

Governance, compliance and security steps

Don’t leave compliance and device control to chance during migration.

• Ensure meeting recordings and transcripts follow retention policies.
• Transfer ownership of assets with provenance/attribution metadata for IP purposes.
• Wipe or reassign corporate headsets using MDM, and maintain inventory logs.
• Update acceptable use policies to reflect new platforms.

Risks and mitigation

• Risk: Data removal before you can export. Mitigation: Prioritize exports and download frequency-limited assets first.
• Risk: User disruption during cutover. Mitigation: Overlap services for 30–60 days and run pilots.
• Risk: Unsupported asset formats. Mitigation: Convert to standard formats (.glb, MP4, JSON) and validate with the preview tool above.

Sample 8‑week migration timeline

1. Week 1: Inventory, exports, stakeholder sign‑off, choose vendor shortlist.
2. Week 2: Set up pilot environment, begin asset conversions, start provisioning test users.
3. Weeks 3–4: Run pilots, rebuild top 10 room templates, validate integrations.
4. Week 5: Train admins and power users, finalize cutover plan and communications.
5. Week 6: Provision all users, import assets, parallel run meetings on both platforms.
6. Week 7: Finalize documentation, start decommission of Workrooms ties (where safe).
7. Week 8: Full cutover, decommission hardware or repurpose, post‑mortem and lessons learned.

Experience‑driven tips from IT and dev teams (2026)

• Keep an audit log of every export action — it helps for compliance and debugging.
• Automate conversions of assets as part of your CI pipeline (assets are code too). See how modding and tooling treat assets as first-class code artifacts.
• Train a distributed set of “space owners” rather than centralizing all rooms under one admin — it speeds recovery and reduces single points of failure.
• Prefer platforms with open APIs and community SDKs — in 2026 ecosystems that embraced WebXR and REST APIs made migrations far easier.

"The migration that looks manual at first becomes repeatable once you treat rooms and assets as deployable artifacts." — IT lead, global dev team.

Appendix A: CSV templates and mapping examples

Room inventory CSV (columns)

roomId,roomName,ownerEmail,assetsManifest,recurringSchedule,notes
room-001,Design Workshop,alice@example.com,manifests/room-001.json,Tues 10:00-11:00,High freq

Asset manifest example (JSON)

{
  "roomId": "room-001",
  "assets": [
    {"id":"chair01","path":"chairs/chair01.glb","license":"company"},
    {"id":"whiteboard1","path":"whiteboards/wb1.png","exportedAt":"2026-01-08T12:00:00Z"}
  ]
}

Final checklist (printable)

1. Export recordings, whiteboards and asset files today.
2. Produce normalized assets (.glb) and a manifest for each room.
3. Choose target platforms and validate a pilot room with real users.
4. Automate user provisioning via SCIM or API.
5. Recreate recurring meetings and update calendar invites.
6. Train owners and communicate cutover dates to users.
7. Decommission or repurpose hardware through your MDM/EAM system.
8. Run a migration post‑mortem and store migration artifacts in version control.

Closing — what to prioritize right now

Start by exporting and inventorying. That single act buys you time and choice. Treat rooms and assets as code — store manifests in git, automate conversions, and provision users via API/SCIM. In 2026 the resilience of your collaboration stack depends on portability, automation, and identity integration.

If you want a templated starter kit: use the example scripts above, adapt the CSV manifest, and run a 2‑week pilot with 10% of power users. Use overlap licensing and keep an archive of all exported data until compliance clears you to delete it.

Call to action

Need a migration checklist tailored to your environment? Download our free migration toolkit (asset manifest templates, SCIM provisioning scripts, and a pilot runbook) or contact our migration team for a 30‑minute audit and a custom 8‑week plan.

Related Reading

• Interoperable Asset Orchestration on Layer‑2: Practical Strategies for 2026
• Beyond Filing: The 2026 Playbook for Collaborative File Tagging, Edge Indexing, and Privacy‑First Sharing
• The Evolution of Developer Onboarding in 2026
• Future Predictions: How 5G, XR, and Low-Latency Networking Will Speed the Urban Experience by 2030
• From Fan to Pro: Turning a Sci‑Fi Fandom into a Career After Franchise Reboots
• Using CRM Data to Substantiate R&D Credits and Marketing Deductions
• Visa Headaches and Big Events: Advice for Pakistani Fans Traveling Abroad for Major Tournaments
• From Gemini Guided Learning to Quantum Upskilling: Building a Personalized Learning Path for Quantum Developers
• Kitchen Tech & Keto: How 2026 Appliances Change Low‑Carb Cooking (Advanced Strategies)