diff --git a/README.md b/README.md
index e6f6fe7..b464711 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ very largest homes may not fit.
 
 - Opens Meta homes (HSL, Clay, glTF), `.fenv` environments and Blender or Unity models; pairs rooms with vistas.
 - Move, rotate, scale, hide and delete objects, with undo and auto-saved versions.
-- Shape the walkable area: auto-generated surfaces, drawn floors, spawns, seats, hotspots, wall spots, gravity zones.
+- Shape the walkable area: auto-generated surfaces, drawn floors, spawns, seats, hotspots, gravity zones.
 - Add a background sound and a picture; set and calculate per-world settings.
 - Saves baked `.fenv` files and leaves out what can't be seen; sends them to the headset in one click.
 - Packs several environments into one `.fbundle` to share or install together ([bundles](docs/bundles.md)).
diff --git a/docs/environments-and-fenv.md b/docs/environments-and-fenv.md
index d9404cd..908ec3d 100644
--- a/docs/environments-and-fenv.md
+++ b/docs/environments-and-fenv.md
@@ -24,7 +24,7 @@ There are two kinds:
 | `fenv.json` | every `.fenv` | The manifest: name, where the home came from (package and version of each `.apk`), and which other members are there. It also holds the environment's own settings. |
 | `scene.bin.lz` | baked | The baked scene, packed with LZMA (much smaller than ZIP's own packing for textures). It is unpacked once, into a cache, then loaded from there. |
 | `apks/...` | wrapped | The original Meta home files (a room, and maybe its vista) |
-| `world.json` | wrapped | The world layer: spawn points, seats, teleport hotspots, walkable surfaces, wall spots, gravity zones. A baked scene carries this inside `scene.bin`. |
+| `world.json` | wrapped | The world layer: spawn points, seats, teleport hotspots, walkable surfaces, gravity zones. A baked scene carries this inside `scene.bin`. |
 | `edits.json` | when you edited | What you changed in Studio: moved and deleted objects, the added sound and how loud the home's own sound plays |
 | a sound file | when you added one | The sound you added in Studio (`.ogg`, `.opus`, `.wav`, `.mp3`, `.flac`), named in `edits.json` |
 | `thumb.png` | usually | The picture the Environments panel shows |
diff --git a/docs/studio-guide.md b/docs/studio-guide.md
index 77b503e..d5e0e56 100644
--- a/docs/studio-guide.md
+++ b/docs/studio-guide.md
@@ -114,7 +114,6 @@ edges, grey are floors you can't reach. **W** shows or hides it.
 | **Seat** | a place to sit: point at it and pull the trigger; its "stand up here" ring is where you get up |
 | **Teleport Hotspot** | a spot the teleport arc snaps to |
 | **Surface** | a box you can scale into a floor, a step or a wall |
-| **Wall Spot** | where SteamVR's panels dock |
 | **Invisible Wall** | stops you; never drawn on the headset. Scale and turn it to fit; where it stands is no longer walkable |
 | **Gravity Zone** | inside it, "down" is the zone's own: a direction, or any surface you stand on |
 
diff --git a/docs/using-frame-home.md b/docs/using-frame-home.md
index eb3aa5f..8ece2dd 100644
--- a/docs/using-frame-home.md
+++ b/docs/using-frame-home.md
@@ -157,7 +157,7 @@ Frame Home restarts.
 | Item | What it does |
 |---|---|
 | View | Normal, Wireframe (every triangle edge), Meshes (each in its own colour), GPU cost (green is cheap, red is costly), Overdraw (bright where surfaces pile up) |
-| World layer | Shows where you can walk (green), surfaces and colliders, spawns, seats, wall spots and gravity zones |
+| World layer | Shows where you can walk (green), surfaces and colliders, spawns, seats and gravity zones |
 | See-through surfaces | Leave out glass, water, glow and fog, to see whether they're what's slow |
 | Cut-out surfaces | Leave out leaves, grass and fences |
 | Sky | Leave out the sky |
diff --git a/src/debug_geom.h b/src/debug_geom.h
index 6f46768..b86ae81 100644
--- a/src/debug_geom.h
+++ b/src/debug_geom.h
@@ -1,6 +1,6 @@
 #pragma once
 // The world layer drawn over the home in the headset (the Debug page's "World layer"): the walkable area as Frame
-// Home walks it, the surfaces and colliders, spawns, seats, hotspots, wall spots and gravity zones, in the colours
+// Home walks it, the surfaces and colliders, spawns, seats, hotspots and gravity zones, in the colours
 // Frame Studio uses for them. Built once per home as guide geometry (guide_geom.h) and appended to the guide each
 // frame. Lines are thin crossed ribbons, so they read from any side without being rebuilt as you move.
 #include "guide_geom.h"
@@ -58,7 +58,7 @@ inline void marker(std::vector<GuideVertex>& o, const WorldPoint& p, float r, fl
 constexpr C kWalk{0.15f, 0.85f, 0.35f, 0.32f}, kWalkEdge{0.25f, 1.0f, 0.45f, 0.9f}, kBridged{0.95f, 0.75f, 0.2f, 0.25f};
 constexpr C kSolid{0.95f, 0.95f, 0.95f, 0.55f}, kObject{1.0f, 0.55f, 0.25f, 0.7f}, kTrigger{0.6f, 0.6f, 1.0f, 0.45f}, kWalkable{0.3f, 1.0f, 0.5f, 0.7f};
 constexpr C kSpawn{0.3f, 0.75f, 1.0f, 0.95f}, kSeat{1.0f, 0.8f, 0.25f, 0.95f}, kHotspot{0.85f, 0.45f, 1.0f, 0.95f};
-constexpr C kSpot{0.4f, 0.9f, 1.0f, 0.8f}, kGravity{1.0f, 0.35f, 0.6f, 0.6f};
+constexpr C kGravity{1.0f, 0.35f, 0.6f, 0.6f};
 
 // Everything, in world space. Mesh surfaces are drawn as their boundary-free wire (every edge) only up to a budget:
 // a mesh collider can be a whole room's geometry.
@@ -165,10 +165,6 @@ inline void build(const HomeWorld& w, const WalkGrid* g, std::vector<GuideVertex
         const P ex{p.pos[0] + p.exit[0], p.pos[1] + p.exit[1] + 0.02f, p.pos[2] + p.exit[2]};
         if (p.exit[0] != 0 || p.exit[2] != 0) { line(o, at, ex, guide::alpha(kSeat, 0.5f)); circle(o, ex, 0.12f, guide::alpha(kSeat, 0.7f)); }
     }
-    for (const WorldWallSpot& s : w.wallSpots) {
-        const float h[3] = {s.width * 0.5f, s.height * 0.5f, 0.01f};
-        box(o, s.world, h, kSpot);
-    }
     for (const WorldGravity& z : w.gravity) {
         if (z.kind == WorldGravity::Planet) circle(o, xf(z.world, {0, 0, 0}), z.radius, kGravity, 64);
         else box(o, z.world, z.half, kGravity);
diff --git a/src/home_report.h b/src/home_report.h
index d2f654c..0a360a1 100644
--- a/src/home_report.h
+++ b/src/home_report.h
@@ -24,7 +24,7 @@ struct HomeReport {
     size_t seeThrough = 0, seeThroughTris = 0, cutout = 0, skinned = 0, animated = 0, lightmapped = 0, sky = 0, programs = 0;
     size_t textures = 0;                // distinct
     double textureMB = 0, decodedMB = 0, geometryMB = 0;   // compressed (as the GPU gets it when it can), decoded RGBA, vertices + indices
-    size_t spawns = 0, seats = 0, hotspots = 0, colliders = 0, wallSpots = 0, gravity = 0;
+    size_t spawns = 0, seats = 0, hotspots = 0, colliders = 0, gravity = 0;
     double walkArea = -1;               // m², < 0: no walkable area known
     double loadSec = 0;                 // set by the caller
     struct Mesh { size_t tris; int mesh; };
@@ -50,8 +50,8 @@ struct HomeReport {
         o += b;
         std::snprintf(b, sizeof b, "%zu textures: %.0f MB compressed, %.0f MB decoded; geometry %.0f MB\n", textures, textureMB, decodedMB, geometryMB);
         o += b;
-        std::snprintf(b, sizeof b, "world: %zu spawns, %zu seats, %zu hotspots, %zu surfaces, %zu wall spots, %zu gravity zones", spawns, seats, hotspots,
-                      colliders, wallSpots, gravity);
+        std::snprintf(b, sizeof b, "world: %zu spawns, %zu seats, %zu hotspots, %zu surfaces, %zu gravity zones", spawns, seats, hotspots,
+                      colliders, gravity);
         o += b;
         o += walkArea >= 0 ? "; walkable " + num(walkArea, 0) + " m²\n" : "\n";
         if (!biggestMeshes.empty()) o += "most triangles:\n";
@@ -72,7 +72,7 @@ struct HomeReport {
         n("meshes", meshes); n("triangles", triangles); n("vertices", vertices); n("seeThrough", seeThrough); n("seeThroughTris", seeThroughTris);
         n("cutout", cutout); n("skinned", skinned); n("animated", animated); n("lightmapped", lightmapped); n("programs", programs);
         n("textures", textures); n("textureMB", std::round(textureMB)); n("decodedMB", std::round(decodedMB)); n("geometryMB", std::round(geometryMB));
-        n("spawns", spawns); n("seats", seats); n("colliders", colliders); n("wallSpots", wallSpots); n("walkArea", std::round(walkArea));
+        n("spawns", spawns); n("seats", seats); n("colliders", colliders); n("walkArea", std::round(walkArea));
         n("loadSec", std::round(loadSec * 10) / 10);
         o += ",\"biggestMeshes\":[";
         for (size_t i = 0; i < biggestMeshes.size(); ++i) o += (i ? ",{\"name\":" : "{\"name\":") + q(meshName(biggestMeshes[i].mesh)) + ",\"tris\":" + num(biggestMeshes[i].tris, 0) + "}";
@@ -209,7 +209,7 @@ inline HomeReport makeHomeReport(const HslScene& s, const HomeWorld* walk = null
     // The world.
     const HomeWorld& w = walk ? *walk : s.world;
     r.spawns = w.spawns.size(); r.seats = w.seats.size(); r.hotspots = w.hotspots.size(); r.colliders = w.colliders.size();
-    r.wallSpots = w.wallSpots.size(); r.gravity = w.gravity.size();
+    r.gravity = w.gravity.size();
     const WalkGrid* g = walk ? walk->walkGridCache.get() : nullptr;
     float floorY = 0;
     if (w.spawns.empty() && w.gravity.empty() && (!g || !g->floorAt(0, 0, 0, 0.5f, 1.0f, floorY)))
diff --git a/src/hsl_scene.cpp b/src/hsl_scene.cpp
index 3b5b77e..8dc324d 100644
--- a/src/hsl_scene.cpp
+++ b/src/hsl_scene.cpp
@@ -485,7 +485,7 @@ bool loadHslScene(const std::vector<std::string>& apkPaths, HslScene& scene, std
             HomeWorld& w = loaders[i]->world;
             auto add = [](auto& to, auto& from) { to.insert(to.end(), std::make_move_iterator(from.begin()), std::make_move_iterator(from.end())); };
             add(scene.world.spawns, w.spawns); add(scene.world.seats, w.seats); add(scene.world.hotspots, w.hotspots);
-            add(scene.world.colliders, w.colliders); add(scene.world.wallSpots, w.wallSpots);
+            add(scene.world.colliders, w.colliders);
             if (!scene.world.empty()) scene.world.origin = "meta";
         }
         for (auto& md : loaders[i]->meshes) {
diff --git a/src/hsl_scene.h b/src/hsl_scene.h
index 275af52..4816de0 100644
--- a/src/hsl_scene.h
+++ b/src/hsl_scene.h
@@ -77,7 +77,7 @@ inline bool loadHslScene(const std::string& apkPath, HslScene& scene, std::strin
 
 // The world to walk in: the home's own (Meta's converted, or a .fenv's) when it has floors or walls; else floors and
 // walls taken from the drawn geometry (opaque, not the sky, not distant scenery) — Clay homes and homes like Theater
-// ship no collision at all. Spawns, seats and wall spots are kept either way.
+// ship no collision at all. Spawns and seats are kept either way.
 // The world carries its walkable area (walkGridCache): the one Frame Studio baked (world.json), else one baked here from
 // the drawn geometry plus the colliders (bakeWalkGrid). Gravity homes also get the geometry's floors and walls as
 // colliders while nothing blocks (the gravity walker reads colliders).
diff --git a/src/main.cpp b/src/main.cpp
index 27a445f..62ea99a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -16,7 +16,6 @@
 #include "hsl_scene.h"
 #include "scene_bake.h"
 #include "locomotion.h"
-#include "panel_dock.h"
 #include "panorama.h"
 #include "core/audio.h"
 #include "env_export.h"
@@ -1087,8 +1086,6 @@ int runVr(const std::vector<std::string>& apks, bool system = false) {
     loco.setOptions(perf.walk, perf.teleport, perf.turn, perf.snapAngle, perf.moveSpeed);
     loco.setRingFallback(!r.guideAvailable());       // Frame Home draws the arc itself; the overlay ring only if it can't
     std::vector<GuideVertex> guideVerts;
-    PanelDock dock;                                  // SteamVR panels docking on the home's wall spots
-
     // Homes are parsed (and their textures decoded) on a worker thread and uploaded between frames,
     // so the headset keeps getting frames while a new home loads.
     const bool follow = apks.empty();                // environment mode: follow ~/frame-home/current
@@ -1415,7 +1412,6 @@ int runVr(const std::vector<std::string>& apks, bool system = false) {
                         LOG("report: %zu things to look at (logs/report.txt), first: %s", pendingReport.problems.size(), pendingReport.problems.front().what.c_str());
                     pendingReport = HomeReport();
                 }
-                dock.setWorld(scene->world);
                 LOG("showing %s (%zu spawns, %zu seats, %zu colliders)", shown.front().c_str(), scene->world.spawns.size(),
                     scene->world.seats.size(), scene->world.colliders.size());
             } else {
@@ -1691,7 +1687,6 @@ int runVr(const std::vector<std::string>& apks, bool system = false) {
         lastFrame = frameNow;
         Mat4 rig;
         loco.rig(rig.m);
-        dock.update(rig.m);
         const Mat4 headWorld = mul(rig, head);
         if (system && widenFixed <= 0) {
             // head turn rate (rad/s) from the rotation since the last frame: angle of R_prev^T * R
@@ -1890,7 +1885,6 @@ int runVr(const std::vector<std::string>& apks, bool system = false) {
     if (worker.joinable()) worker.join();
     if (soundJob.joinable()) soundJob.join();
     publisher.finish();
-    dock.stop();
     // SteamVR first: its client holds our Vulkan device for the frames it composited, and cleaning up after a
     // device we'd already destroyed crashed every exit (game launches, restarts).
     vr::VR_Shutdown();
diff --git a/src/overlays.h b/src/overlays.h
index 7694ff4..01b17d1 100644
--- a/src/overlays.h
+++ b/src/overlays.h
@@ -1,7 +1,7 @@
 #pragma once
 // SteamVR's panels (overlays) of every app. OpenVR can't list them, but a handle is (slot << 32 | serial) with both
 // small, so probing that range finds them all; a whole sweep takes about 0.1 s. Used to tell whether a hand points
-// at a panel (frame-switcher) and to dock free-floating panels on a home's wall spots (Frame Home).
+// at a panel (frame-switcher).
 #include <openvr.h>
 
 #include <cstring>
diff --git a/src/panel_dock.h b/src/panel_dock.h
deleted file mode 100644
index 5eca702..0000000
--- a/src/panel_dock.h
+++ /dev/null
@@ -1,177 +0,0 @@
-#pragma once
-// Wall spots at work: a SteamVR panel (a desktop or game window, any free-floating overlay) let go of near one of
-// the home's wall spots docks onto it — flush with the wall, facing the room, no wider than the spot — and stays
-// there as you walk and teleport (panels live in tracking space, so a docked one is re-placed from the home's frame
-// whenever you move). Grab it away and it's free again, back at its own size. Docked panels are re-placed only when
-// the rig moves: setting one every frame would overwrite a grab before it could be seen.
-// Meta's homes mark these spots with WallPlacementComponent; Frame Studio edits them (World > Wall Spot).
-#include "core/world.h"
-#include "overlays.h"
-
-#include <openvr.h>
-
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-#include <map>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-class PanelDock {
-public:
-    ~PanelDock() { stop(); }
-    // Before VR_Shutdown: the scanner calls into SteamVR's client library, which shutting down unloads.
-    void stop() { stop_ = true; if (scanner_.joinable()) scanner_.join(); }
-
-    void setWorld(const HomeWorld& w) {
-        undockAll();
-        spots_ = w.wallSpots;
-        if (!spots_.empty() && !scanner_.joinable()) scanner_ = std::thread([this] { scanLoop(); });
-    }
-
-    // Once per frame with worldFromTracking.
-    void update(const float rig[16]) {
-        if (spots_.empty()) return;
-        std::vector<OverlayInfo> panels;
-        { std::lock_guard<std::mutex> l(mutex_); panels = panels_; }
-        float inv[16];
-        invertRigid(rig, inv);
-        const auto now = std::chrono::steady_clock::now();
-        vr::IVROverlay* ov = vr::VROverlay();
-        // Panels whose app went away: their state (and any spot they held) goes too.
-        for (auto it = state_.begin(); it != state_.end();) {
-            bool present = false;
-            for (const OverlayInfo& p : panels) present |= p.handle == it->first;
-            it = present ? std::next(it) : state_.erase(it);
-        }
-        for (const OverlayInfo& p : panels) {
-            if (!ov->IsOverlayVisible(p.handle)) continue;
-            vr::VROverlayTransformType tt;
-            if (ov->GetOverlayTransformType(p.handle, &tt) != vr::VROverlayError_None || tt != vr::VROverlayTransform_Absolute) continue;
-            vr::ETrackingUniverseOrigin origin;
-            vr::HmdMatrix34_t cur;
-            if (ov->GetOverlayTransformAbsolute(p.handle, &origin, &cur) != vr::VROverlayError_None) continue;
-            if (origin != vr::TrackingUniverseStanding) continue;   // the spots are placed in standing space
-            State& s = state_[p.handle];
-            if (s.spot >= 0) {
-                // Docked: still where we put it? Then keep it on the wall as the rig moves; else it was grabbed away.
-                if (differs(cur, s.placed, 0.03f)) { undock(p.handle, s, "moved away"); s.still = now; s.last = cur; continue; }
-                // Re-placed only once the rig has moved a few millimetres since it was placed (per panel, so one
-                // hidden while you teleported is put right when it shows again). Tiny continuous rig changes —
-                // seated eye-height easing, step easing — would otherwise overwrite a grab every frame.
-                float moved = 0;
-                for (int k = 0; k < 16; ++k) moved = std::max(moved, std::fabs(rig[k] - s.rig[k]));
-                if (moved < 0.005f) continue;
-                vr::HmdMatrix34_t m = spotInTracking(s.spot, inv, s.flip);
-                ov->SetOverlayTransformAbsolute(p.handle, origin, &m);
-                s.placed = m;
-                std::memcpy(s.rig, rig, sizeof s.rig);
-                continue;
-            }
-            if (differs(cur, s.last, 0.002f)) { s.last = cur; s.still = now; continue; }   // still moving
-            if (now - s.still < std::chrono::milliseconds(500) || s.cooldown > now) continue;
-            // At rest: dock onto the nearest free spot within 0.6 m.
-            float pt[3];
-            for (int k = 0; k < 3; ++k) pt[k] = rig[k] * cur.m[0][3] + rig[4 + k] * cur.m[1][3] + rig[8 + k] * cur.m[2][3] + rig[12 + k];
-            int best = -1;
-            float bestD = 0.6f;
-            for (size_t i = 0; i < spots_.size(); ++i) {
-                if (taken(static_cast<int>(i))) continue;
-                const float* c = &spots_[i].world[12];
-                const float d = std::sqrt((pt[0] - c[0]) * (pt[0] - c[0]) + (pt[1] - c[1]) * (pt[1] - c[1]) + (pt[2] - c[2]) * (pt[2] - c[2]));
-                if (d < bestD) { bestD = d; best = static_cast<int>(i); }
-            }
-            if (best < 0) { s.cooldown = now + std::chrono::milliseconds(500); continue; }
-            // Face the panel the way it was facing (towards the user), whichever way the spot's frame points.
-            const float* z = &spots_[best].world[8];
-            float pz[3];
-            for (int k = 0; k < 3; ++k) pz[k] = rig[k] * cur.m[0][2] + rig[4 + k] * cur.m[1][2] + rig[8 + k] * cur.m[2][2];
-            s.flip = z[0] * pz[0] + z[1] * pz[1] + z[2] * pz[2] < 0;
-            ov->GetOverlayWidthInMeters(p.handle, &s.width);
-            const float fit = std::min(s.width, spots_[best].width);
-            ov->SetOverlayWidthInMeters(p.handle, fit);
-            vr::HmdMatrix34_t m = spotInTracking(best, inv, s.flip);
-            ov->SetOverlayTransformAbsolute(p.handle, origin, &m);
-            s.placed = m;
-            std::memcpy(s.rig, rig, sizeof s.rig);
-            s.spot = best;
-            std::fprintf(stderr, "frame-home: docked panel %s on wall spot %s\n", p.key.c_str(), spots_[best].name.c_str());
-        }
-    }
-
-private:
-    struct State {
-        int spot = -1;
-        bool flip = false;
-        float width = 1;                                    // its own width, given back when it leaves the wall
-        vr::HmdMatrix34_t placed = {}, last = {};
-        float rig[16] = {};                                 // the rig it was last placed for
-        std::chrono::steady_clock::time_point still{}, cooldown{};
-    };
-    std::vector<WorldWallSpot> spots_;
-    std::map<vr::VROverlayHandle_t, State> state_;
-    std::vector<OverlayInfo> panels_;
-    std::mutex mutex_;
-    std::thread scanner_;
-    std::atomic<bool> stop_{false};
-
-    // The panel list, refreshed every 2 s off the frame loop (a sweep takes ~0.1 s).
-    void scanLoop() {
-        while (!stop_) {
-            std::vector<OverlayInfo> found;
-            for (const OverlayInfo& o : listOverlays())
-                if (isUserPanel(o) && o.key.rfind("system.", 0) != 0) found.push_back(o);
-            { std::lock_guard<std::mutex> l(mutex_); panels_ = std::move(found); }
-            for (int i = 0; i < 20 && !stop_; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
-    }
-
-    bool taken(int spot) const {
-        for (const auto& kv : state_) if (kv.second.spot == spot) return true;
-        return false;
-    }
-
-    void undock(vr::VROverlayHandle_t h, State& s, const char* why) {
-        vr::VROverlay()->SetOverlayWidthInMeters(h, s.width);
-        std::fprintf(stderr, "frame-home: panel left wall spot %s (%s)\n", spots_[s.spot].name.c_str(), why);
-        s.spot = -1;
-        s.cooldown = std::chrono::steady_clock::now() + std::chrono::seconds(2);
-    }
-
-    void undockAll() {
-        for (auto& kv : state_) if (kv.second.spot >= 0) undock(kv.first, kv.second, "new home");
-        state_.clear();
-    }
-
-    // The spot's frame in tracking space, 1 cm off the wall, optionally turned to face the other way.
-    vr::HmdMatrix34_t spotInTracking(int i, const float inv[16], bool flip) const {
-        float w[16];
-        std::memcpy(w, spots_[i].world, 64);
-        for (int c = 0; c < 3; ++c) {   // unit axes (a scaled spot frame would scale the panel)
-            const float L = std::sqrt(w[c * 4] * w[c * 4] + w[c * 4 + 1] * w[c * 4 + 1] + w[c * 4 + 2] * w[c * 4 + 2]);
-            if (L > 1e-6f) for (int r = 0; r < 3; ++r) w[c * 4 + r] /= L;
-        }
-        if (flip) for (int r = 0; r < 3; ++r) { w[r] = -w[r]; w[8 + r] = -w[8 + r]; }   // 180 degrees about Y
-        for (int r = 0; r < 3; ++r) w[12 + r] += w[8 + r] * 0.01f;
-        float t[16];
-        for (int c = 0; c < 4; ++c)
-            for (int r = 0; r < 4; ++r) t[c * 4 + r] = inv[r] * w[c * 4] + inv[4 + r] * w[c * 4 + 1] + inv[8 + r] * w[c * 4 + 2] + inv[12 + r] * w[c * 4 + 3];
-        vr::HmdMatrix34_t m;
-        for (int r = 0; r < 3; ++r) for (int c = 0; c < 4; ++c) m.m[r][c] = t[c * 4 + r];
-        return m;
-    }
-
-    static void invertRigid(const float m[16], float o[16]) {
-        for (int r = 0; r < 3; ++r) for (int c = 0; c < 3; ++c) o[c * 4 + r] = m[r * 4 + c];
-        for (int r = 0; r < 3; ++r) o[12 + r] = -(o[r] * m[12] + o[4 + r] * m[13] + o[8 + r] * m[14]);
-        o[3] = o[7] = o[11] = 0; o[15] = 1;
-    }
-
-    static bool differs(const vr::HmdMatrix34_t& a, const vr::HmdMatrix34_t& b, float eps) {
-        for (int r = 0; r < 3; ++r) for (int c = 0; c < 4; ++c) if (std::fabs(a.m[r][c] - b.m[r][c]) > eps) return true;
-        return false;
-    }
-};
diff --git a/src/perf_settings.h b/src/perf_settings.h
index 562f691..b501390 100644
--- a/src/perf_settings.h
+++ b/src/perf_settings.h
@@ -123,7 +123,7 @@ struct PerfSettings {
 // why a home looks or runs wrong, not for keeping: Frame Home clears the file each time it starts.
 struct DebugSettings {
     int view = 0;                       // HslRenderer::DebugView: 0 normal, 1 wireframe, 2 meshes, 3 GPU cost, 4 overdraw
-    int world = 0;                      // the world layer drawn over the home: walkable area, surfaces, spawns, seats, wall spots
+    int world = 0;                      // the world layer drawn over the home: walkable area, surfaces, spawns, seats
     int hideSeeThrough = 0, hideCutout = 0, hideSky = 0;   // leave those parts of the home out
     int shot = 0;                       // asks for a picture of what's shown (logs/frame-<time>.png): the time it was asked
                                         // (Unix seconds); one from before Frame Home started is old
diff --git a/src/scene_bake.cpp b/src/scene_bake.cpp
index eee4c92..e3c947b 100644
--- a/src/scene_bake.cpp
+++ b/src/scene_bake.cpp
@@ -177,8 +177,6 @@ void writeWorld(Writer& w, const HomeWorld& wd, const std::vector<MeshData>& mes
         w.str(c.mesh);
     }
     w.vec(wd.walkPositions); w.vec(wd.walkIndices);
-    w.u(static_cast<u32>(wd.wallSpots.size()));
-    for (const WorldWallSpot& ws : wd.wallSpots) { w.str(ws.name); w.fa(ws.world, 16); w.f(ws.width); w.f(ws.height); }
     w.u(static_cast<u32>(wd.gravity.size()));
     for (const WorldGravity& g : wd.gravity) { w.str(g.name); w.pod(g.kind); w.fa(g.world, 16); w.fa(g.half, 3); w.f(g.radius); w.pod(g.priority); }
     w.f(wd.fallLimit);
@@ -202,8 +200,8 @@ void readWorld(Reader& r, HomeWorld& wd, u32 version, std::vector<std::pair<size
         if (version >= 4) c.mesh = r.str();
     }
     wd.walkPositions = r.vec<float>(); wd.walkIndices = r.vec<u32>();
-    wd.wallSpots.resize(r.count(76));
-    for (WorldWallSpot& ws : wd.wallSpots) { if (r.bad) break; ws.name = r.str(); r.fa(ws.world, 16); ws.width = r.f(); ws.height = r.f(); }
+    if (version < 14)                    // wall spots, now removed: read past them
+        for (u32 n = r.count(76); n-- && !r.bad;) { float m[16]; r.str(); r.fa(m, 16); r.f(); r.f(); }
     if (version >= 6) {
         wd.gravity.resize(r.count(92));
         for (WorldGravity& g : wd.gravity) { if (r.bad) break; g.name = r.str(); g.kind = r.pod<int>(); r.fa(g.world, 16); r.fa(g.half, 3); g.radius = r.f(); g.priority = r.pod<int>(); }
diff --git a/src/scene_bake.h b/src/scene_bake.h
index ed25643..624ef42 100644
--- a/src/scene_bake.h
+++ b/src/scene_bake.h
@@ -11,7 +11,7 @@
 #include <string>
 #include <vector>
 
-constexpr u32 kSceneBakeVersion = 13;  // 2: world; 3: HDR maps as ASTC, binary world; 4: roles; 5: mesh refs; 6: gravity; 7: mesh paths; 8: ambience name; 9: compressed 8-bit lightmaps; 10: reflection cube as ASTC; 11: walkable area (and simplified colliders); 12: prepared and specialized shaders; 13: Clay / glTF CPU animation
+constexpr u32 kSceneBakeVersion = 14;  // 2: world; 3: HDR maps as ASTC, binary world; 4: roles; 5: mesh refs; 6: gravity; 7: mesh paths; 8: ambience name; 9: compressed 8-bit lightmaps; 10: reflection cube as ASTC; 11: walkable area (and simplified colliders); 12: prepared and specialized shaders; 13: Clay / glTF CPU animation; 14: wall spots removed
 
 struct VisibilityResult;
 struct ObjectEdit;
diff --git a/src/switcher.cpp b/src/switcher.cpp
index 6dd5ba9..64ba379 100644
--- a/src/switcher.cpp
+++ b/src/switcher.cpp
@@ -902,7 +902,7 @@ struct Panel {
         "Hold still stops the environment's moving parts; animated environments then cost less.",
         "With the menu open the environment is only its backdrop. Half rate leaves the GPU to the menu and its apps.",
         "Wireframe: every triangle edge. Meshes: each in its own colour. GPU cost: green is cheap, red is costly. Overdraw: bright where surfaces pile up.",
-        "Where you can walk (green), surfaces and colliders, spawns, seats, wall spots and gravity zones.",
+        "Where you can walk (green), surfaces and colliders, spawns, seats and gravity zones.",
         "Glass, water, glow and fog. Leave them out to see whether they're what's slow.",
         "Leaves, grass and fences. Leave them out to see whether they're what's slow.",
         "The sky around the environment.",
diff --git a/src/world_gen.h b/src/world_gen.h
index 2b03458..0d06f4b 100644
--- a/src/world_gen.h
+++ b/src/world_gen.h
@@ -7,9 +7,8 @@
 // Off unless GenParams asks (guesses, and a wrong one is worse than none):
 //   walls      — Wall boxes on flat upright faces that are architecture (named a wall, or 2.4 m+ / up to the ceiling),
 //                and along drops inside a tall structure
-//   wall spots — the middle of a tall, solid stretch of wall with room to stand back from it (SteamVR panels)
 //   seats      — a top 35-62 cm over the floor with a backrest behind and floor in front, or a stool
-//   hotspots   — in front of wall spots, lookouts, the middles of open spaces
+//   hotspots   — lookouts, the middles of open spaces
 // Everything made is named "Auto …" (Frame Studio replaces them on a re-run).
 #include "walkgrid.h"
 
@@ -25,19 +24,18 @@ struct GenParams {
     float wallMinHeight = 0.9f;         // a wall is at least this tall over the floor in front of it (a railing)
     float wallMinRun = 0.6f;            // shortest wall (m)
     float seatLo = 0.35f, seatHi = 0.62f;   // a seat's top over the floor in front of it (m): low lounge sofas to thick cushions
-    int maxSpots = 5, maxHotspots = 12;
+    int maxHotspots = 12;
     // Seats and hotspots are guesses about how people use a place, and a wrong one (a seat on a planter's rim) is worse
-    // than none: off unless asked for. Auto-generate makes the floor, the walls, the objects' collision and wall spots.
+    // than none: off unless asked for. Auto-generate makes the floor, the walls and the objects' collision.
     bool seats = false, hotspots = false;
-    // Walls (boxes on faces judged to be walls) and wall spots are guesses too: off. Every mesh gets its own collision
+    // Walls (boxes on faces judged to be walls) are guesses too: off. Every mesh gets its own collision
     // instead (GenResult::objects), whatever it is.
-    bool walls = false, spots = false;
+    bool walls = false;
 };
 
 struct GenResult {
     std::vector<WorldCollider> walls, objects;
     std::vector<WorldPoint> seats, hotspots;
-    std::vector<WorldWallSpot> spots;
 };
 
 namespace world_gen_detail {
@@ -618,63 +616,6 @@ inline GenResult generateWorldItems(const WalkGrid& g, const HomeWorld& have, co
         for (WorldCollider& c : encl) out.walls.push_back(std::move(c));
     }
 
-    // ── Wall spots: the solid middle of a tall wall, with room to stand back from it ──
-    if (P.spots) {
-        const float sx = have.spawns.empty() ? 0.0f : have.spawns[0].pos[0], sz = have.spawns.empty() ? 0.0f : have.spawns[0].pos[2];
-        struct Cand { float score, x, y, z, ux, uz, fx, fz, width, height; };
-        std::vector<Cand> cands;
-        for (const Run& rn : runs) {
-            const Wall& w = *rn.w;
-            const float L = (rn.i1 - rn.i0 + 1) * kCell;
-            if (w.glass || w.hint == kHintBlocker || L < 1.6f || rn.top - rn.floor < 2.2f) continue;   // (a blocker wall: Meta's, not one to hang on)
-            const float width = std::min(L - 0.4f, 2.4f), height = std::clamp(rn.top - rn.floor - 1.0f, 0.9f, 1.4f);
-            const float bottom = rn.floor + 0.85f;
-            const int wc = static_cast<int>(std::ceil(width / kCell));
-            const float fx = w.nx * rn.side, fz = w.nz * rn.side, ux = -w.nz, uz = w.nx;
-            // slide along the wall from its middle until the panel sits on solid wall (no window, door or gap)
-            const int mid = (rn.i0 + rn.i1) / 2;
-            bool placed = false;
-            for (int off = 0; off <= (rn.i1 - rn.i0 - wc) / 2 + 1 && !placed; off += 2)
-                for (int sgn : {1, -1}) {
-                    const int c0 = mid + sgn * off - wc / 2, c1 = c0 + wc - 1;
-                    if (c0 < rn.i0 || c1 > rn.i1 || w.fill(c0, c1, bottom - 0.1f, bottom + height + 0.1f) < 0.97f) continue;
-                    const float s = w.s0 + (c0 + c1 + 1) * 0.5f * kCell, px = w.nx * w.d + ux * s, pz = w.nz * w.d + uz * s;
-                    // clear air in front at panel height (2.5 m straight out, 1.5 m across all of it), floor 2 m back
-                    bool clear = true;
-                    for (float t = 0.3f; t <= 2.5f && clear; t += 0.2f)
-                        for (float lat : {-width * 0.5f, -width * 0.25f, 0.0f, width * 0.25f, width * 0.5f})
-                            if ((lat == 0 || t <= 1.5f) && solidBetween(g, px + fx * t + ux * lat, pz + fz * t + uz * lat, rn.floor + 0.7f, rn.floor + 2.2f)) { clear = false; break; }
-                    if (!clear || !areaFloor(g, px + fx * 2.0f, pz + fz * 2.0f, rn.floor, 0.3f)) continue;
-                    // a wall round a space, not a slab standing between two paths (floor behind it too)
-                    bool divider = false;
-                    for (float t : {0.3f, 0.5f, 0.7f}) divider |= areaFloor(g, px - fx * t, pz - fz * t, rn.floor, 0.5f) != nullptr;
-                    if (divider) continue;
-                    const float toSpawn = std::hypot(sx - px, sz - pz), facing = ((sx - px) * fx + (sz - pz) * fz) / std::max(0.1f, toSpawn);
-                    cands.push_back({width + (facing > 0.3f && toSpawn < 9 ? 2.0f : 0.0f), px + fx * 0.02f, bottom + height * 0.5f, pz + fz * 0.02f, ux, uz, fx, fz, width, height});
-                    placed = true;
-                    break;
-                }
-        }
-        std::sort(cands.begin(), cands.end(), [](const Cand& a, const Cand& b) { return a.score > b.score; });
-        for (const Cand& c : cands) {
-            if (static_cast<int>(out.spots.size()) >= P.maxSpots) break;
-            bool close = false;
-            for (const WorldWallSpot& w : have.wallSpots) close |= std::hypot(w.world[12] - c.x, w.world[14] - c.z) < 1.5f && std::fabs(w.world[13] - c.y) < 1.5f;
-            for (const WorldWallSpot& w : out.spots) close |= std::hypot(w.world[12] - c.x, w.world[14] - c.z) < 3.0f;
-            if (close) continue;
-            // the frame: X along the wall, Y up, Z (= X x Y) out into the room
-            float ux = c.ux, uz = c.uz;
-            if (-uz * c.fx + ux * c.fz < 0) { ux = -ux; uz = -uz; }
-            WorldWallSpot w;
-            w.name = "Auto wall spot";
-            const float m[16] = {ux, 0, uz, 0, 0, 1, 0, 0, -uz, 0, ux, 0, c.x, c.y, c.z, 1};
-            std::copy_n(m, 16, w.world);
-            w.width = c.width;
-            w.height = c.height;
-            out.spots.push_back(w);
-        }
-    }
-
     // ── Seats: where on a seat-high top you'd sit — a backrest behind, floor in front — or a free-standing stool ──
     if (P.seats) {
         const float cs = g.p.cell;
@@ -994,23 +935,7 @@ inline GenResult generateWorldItems(const WalkGrid& g, const HomeWorld& have, co
             out.hotspots.push_back(p);
             taken.push_back({x, y, z});
         };
-        // 1. in front of each wall spot, looking at it
-        std::vector<const WorldWallSpot*> spots;
-        for (const WorldWallSpot& w : have.wallSpots) spots.push_back(&w);
-        for (const WorldWallSpot& w : out.spots) spots.push_back(&w);
-        for (const WorldWallSpot* w : spots)
-            for (float sgn : {1.0f, -1.0f}) {
-                const float fx = w->world[8] * sgn, fz = w->world[10] * sgn, fl = std::hypot(fx, fz);
-                if (fl < 0.5f) continue;
-                float x = w->world[12] + fx / fl * 2.2f, z = w->world[14] + fz / fl * 2.2f;
-                const WalkSpan* f = areaFloor(g, x, z, w->world[13] - 1.5f, 1.2f);
-                if (!f) continue;
-                const float y = f->hi;
-                if (!g.roomAt(x, y, z, 0.5f) || !free(x, y, z, 2.0f)) continue;
-                add(x, y, z, -fx / fl, -fz / fl);
-                break;
-            }
-        // 2. lookouts: where the area's edge is a drop with open air beyond it (a terrace's rail, a balcony)
+        // 1. lookouts: where the area's edge is a drop with open air beyond it (a terrace's rail, a balcony)
         {
             struct Edge { float x, y, z, ox, oz; };
             std::vector<Edge> view;
@@ -1041,7 +966,7 @@ inline GenResult generateWorldItems(const WalkGrid& g, const HomeWorld& have, co
                 ++lookouts;
             }
         }
-        // 3. the middles of open spaces (1.5 m or more from any edge, 6 m apart, five at most), facing the longest view
+        // 2. the middles of open spaces (1.5 m or more from any edge, 6 m apart, five at most), facing the longest view
         {
             std::vector<std::array<float, 4>> cand;
             for (int z = 0; z < g.nz; z += 2)
diff --git a/studio/studio.cpp b/studio/studio.cpp
index c2cc8d5..8631872 100644
--- a/studio/studio.cpp
+++ b/studio/studio.cpp
@@ -393,13 +393,13 @@ struct UndoStep {
 };
 
 // The world layer's kinds of things (Studio's world editor).
-enum WorldKind { kSpawn, kSeat, kHotspot, kCollider, kWallSpot, kGravity, kWorldKinds };
-const char* kWorldNames[kWorldKinds] = {"Spawns", "Seats", "Teleport Hotspots", "Walls & Surfaces", "Wall Spots", "Gravity Zones"};
+enum WorldKind { kSpawn, kSeat, kHotspot, kCollider, kGravity, kWorldKinds };
+const char* kWorldNames[kWorldKinds] = {"Spawns", "Seats", "Teleport Hotspots", "Walls & Surfaces", "Gravity Zones"};
 
 // What the viewport can show, each with its own switch (View > Show, the explorer's World headers).
-enum ShowCat { kShowSpawns, kShowSeats, kShowHotspots, kShowFloors, kShowWalls, kShowSolidMeshes, kShowTriggers, kShowWallSpots, kShowGravity, kShowWalkArea, kShowUnreached, kShowCats };
-const char* kShowNames[kShowCats] = {"Spawn points", "Seats", "Teleport hotspots", "Drawn floors", "Surface shapes", "Surface & collider meshes", "Triggers", "Wall spots", "Gravity zones", "Walkable area", "Floors out of reach"};
-const uint32_t kShowColors[kShowCats] = {0x3fd2ff, 0x5fe07a, 0xffd84a, 0x4cd964, 0xff7a2e, 0xffa033, 0x9a9a9a, 0x5b8def, 0xc07aff, 0x2ec756, 0x808080};
+enum ShowCat { kShowSpawns, kShowSeats, kShowHotspots, kShowFloors, kShowWalls, kShowSolidMeshes, kShowTriggers, kShowGravity, kShowWalkArea, kShowUnreached, kShowCats };
+const char* kShowNames[kShowCats] = {"Spawn points", "Seats", "Teleport hotspots", "Drawn floors", "Surface shapes", "Surface & collider meshes", "Triggers", "Gravity zones", "Walkable area", "Floors out of reach"};
+const uint32_t kShowColors[kShowCats] = {0x3fd2ff, 0x5fe07a, 0xffd84a, 0x4cd964, 0xff7a2e, 0xffa033, 0x9a9a9a, 0xc07aff, 0x2ec756, 0x808080};
 
 // A gravity zone's kind (WorldGravity::Kind), as Studio names and explains it.
 const char* kGravityNames[3] = {"Direction", "Planet", "Walk on any surface"};
@@ -673,7 +673,7 @@ struct Studio {
     int wKind = -1, wIndex = -1;
     bool showWorld = true;
     // What the viewport shows. View only: the per-item eyes (hidden) are kept with the world layer.
-    bool showCat[kShowCats] = {true, true, true, true, true, false, false, true, true, true, true};
+    bool showCat[kShowCats] = {true, true, true, true, true, false, false, true, true, true};
     bool showMeshes = true;                 // the home's own objects
     bool isolating = false;                 // View > Show Only Selected (I)
     int isoObject = -1, isoKind = -1, isoIndex = -1;
@@ -991,8 +991,8 @@ struct Studio {
         ImGui::TextWrapped("%zu meshes, %.2f M triangles (%zu see-through, %zu cut-out, %zu animated), %zu shaders", r.meshes, r.triangles / 1e6, r.seeThrough,
                            r.cutout, r.animated, r.programs);
         ImGui::TextWrapped("%zu textures: %.0f MB compressed, %.0f MB decoded; geometry %.0f MB", r.textures, r.textureMB, r.decodedMB, r.geometryMB);
-        if (r.walkArea >= 0) ImGui::TextWrapped("%.0f m² to walk on; %zu spawns, %zu seats, %zu surfaces, %zu wall spots", r.walkArea, r.spawns, r.seats, r.colliders, r.wallSpots);
-        else ImGui::TextWrapped("%zu spawns, %zu seats, %zu surfaces, %zu wall spots", r.spawns, r.seats, r.colliders, r.wallSpots);
+        if (r.walkArea >= 0) ImGui::TextWrapped("%.0f m² to walk on; %zu spawns, %zu seats, %zu surfaces", r.walkArea, r.spawns, r.seats, r.colliders);
+        else ImGui::TextWrapped("%zu spawns, %zu seats, %zu surfaces", r.spawns, r.seats, r.colliders);
         if (ImGui::Button("Check Again")) report.reset();
         ImGui::SameLine();
         if (ImGui::Button("Copy as Text")) ImGui::SetClipboardText(r.text().c_str());
@@ -1131,7 +1131,7 @@ struct Studio {
         static const char* views[] = {"Normal", "Wireframe", "Meshes", "GPU cost", "Overdraw"};
         if (int p = choice("View##hd", views, 5, d.view, "What Frame Home draws: the environment, or how it's made and what it costs."); p >= 0) { d.view = p; changed = true; }
         static const char* wl[] = {"Hidden", "Shown"};
-        if (int p = choice("World layer##hd", wl, 2, d.world, "Where you can walk (green), surfaces and colliders, spawns, seats, wall spots and gravity zones."); p >= 0) {
+        if (int p = choice("World layer##hd", wl, 2, d.world, "Where you can walk (green), surfaces and colliders, spawns, seats and gravity zones."); p >= 0) {
             d.world = p; changed = true; }
         static const char* lo[] = {"Shown", "Left out"};
         if (int p = choice("See-through##hd", lo, 2, d.hideSeeThrough, "Glass, water, glow and fog."); p >= 0) { d.hideSeeThrough = p; changed = true; }
@@ -2961,7 +2961,7 @@ struct Studio {
         bool ok = false;
         int replaced = 0, kept = 0;
         bool spawnAdded = false;
-        int walls = 0, objects = 0, colliders = 0, seats = 0, spots = 0, hotspots = 0;   // world items made
+        int walls = 0, objects = 0, colliders = 0, seats = 0, hotspots = 0;   // world items made
         WalkReport walk;
         float ms = 0;
     } autoReport;
@@ -3006,11 +3006,10 @@ struct Studio {
         w.colliders.erase(std::remove_if(w.colliders.begin(), w.colliders.end(), [](const WorldCollider& c) { return isAuto(c.name); }), w.colliders.end());
         r.replaced = static_cast<int>(n0 - w.colliders.size());
         w.spawns.erase(std::remove_if(w.spawns.begin(), w.spawns.end(), [](const WorldPoint& p) { return p.name == "Auto spawn"; }), w.spawns.end());
-        // the walls, seats, wall spots and hotspots it made last time go too (yours stay)
+        // the walls, seats and hotspots it made last time go too (yours stay)
         auto autoPoint = [](const WorldPoint& p) { return isAuto(p.name); };
         w.seats.erase(std::remove_if(w.seats.begin(), w.seats.end(), autoPoint), w.seats.end());
         w.hotspots.erase(std::remove_if(w.hotspots.begin(), w.hotspots.end(), autoPoint), w.hotspots.end());
-        w.wallSpots.erase(std::remove_if(w.wallSpots.begin(), w.wallSpots.end(), [](const WorldWallSpot& s) { return isAuto(s.name); }), w.wallSpots.end());
         for (const Object& o : objects) if (!o.deleted && surfaceIndex(o) >= 0) ++r.kept;
         const auto t0 = std::chrono::steady_clock::now();
         {   // Everything that can be a floor is one: a mesh you stand on somewhere (the floor, stairs, a rug, a deck,
@@ -3166,9 +3165,8 @@ struct Studio {
         if (r.objects) { swatch(kShowColors[kShowSolidMeshes]); ImGui::Text("%d floor mesh%s made surfaces: walkable where flat, blocking where too steep", r.objects, r.objects == 1 ? "" : "es"); }
         if (r.colliders) { swatch(kRoleColors[WorldCollider::Object]); ImGui::Text("%d object%s given a collider: you don't walk through %s", r.colliders, r.colliders == 1 ? "" : "s", r.colliders == 1 ? "it" : "them"); }
         if (r.seats) { swatch(kShowColors[kShowSeats]); ImGui::Text("%d seat%s on the chairs, sofas and stools it found", r.seats, r.seats == 1 ? "" : "s"); }
-        if (r.spots) { swatch(kShowColors[kShowWallSpots]); ImGui::Text("%d wall spot%s for panels, on large flat walls", r.spots, r.spots == 1 ? "" : "s"); }
         if (r.hotspots) { swatch(kShowColors[kShowHotspots]); ImGui::Text("%d teleport hotspot%s spread over the floor", r.hotspots, r.hotspots == 1 ? "" : "s"); }
-        if (r.walls + r.objects + r.colliders + r.seats + r.spots + r.hotspots) ImGui::TextDisabled("They're all named \"Auto …\" in the World list: edit or delete any; running it again replaces them.");
+        if (r.walls + r.objects + r.colliders + r.seats + r.hotspots) ImGui::TextDisabled("They're all named \"Auto …\" in the World list: edit or delete any; running it again replaces them.");
         ImGui::Spacing();
         ImGui::PushStyleColor(ImGuiCol_Text, hex(kDim));
         if (r.kept) ImGui::Text(r.kept == 1 ? "1 object keeps the surface you gave it (Surface or Walk through)" : "%d objects keep the surfaces you gave them (Surface or Walk through)", r.kept);
@@ -3243,7 +3241,7 @@ struct Studio {
         if (ImGui::Button(walkSaved() ? "Auto-generate Again" : "Auto-generate Walkable Surfaces", ImVec2(-1, 0))) autoGenerate();
         if (ImGui::IsItemHovered())
             ImGui::SetTooltip("Bakes where you can walk from everything solid in the home and saves it with it (one undo step),\n"
-                              "and adds walls along its edges, seats on chairs and sofas, wall spots for panels and teleport hotspots.\n"
+                              "and adds walls along its edges, seats on chairs and sofas and teleport hotspots.\n"
                               "Floors need headroom; furniture, plants, railings and walls block; steps up to the step height connect;\n"
                               "seams are bridged; floors you can't reach from the start are left out. Object Surfaces override it.");
     }
@@ -3285,7 +3283,7 @@ struct Studio {
         updateTitle();
     }
 
-    // ── World layer (spawns, seats, hotspots, walls, wall spots, walkable areas) ──
+    // ── World layer (spawns, seats, hotspots, walls, walkable areas) ──
 
     int worldCount(int kind) const {
         if (!scene) return 0;
@@ -3295,7 +3293,6 @@ struct Studio {
             case kSeat: return static_cast<int>(w.seats.size());
             case kHotspot: return static_cast<int>(w.hotspots.size());
             case kCollider: return static_cast<int>(w.colliders.size());
-            case kWallSpot: return static_cast<int>(w.wallSpots.size());
             case kGravity: return static_cast<int>(w.gravity.size());
             default: return 0;
         }
@@ -3306,7 +3303,6 @@ struct Studio {
             case kSpawn: return kShowSpawns;
             case kSeat: return kShowSeats;
             case kHotspot: return kShowHotspots;
-            case kWallSpot: return kShowWallSpots;
             case kGravity: return kShowGravity;
             default: {
                 const WorldCollider& c = scene->world.colliders[i];
@@ -3321,7 +3317,6 @@ struct Studio {
     bool* worldHidden(int kind, int i) {
         if (WorldPoint* p = worldPoint(kind, i)) return &p->hidden;
         if (kind == kCollider) return &scene->world.colliders[i].hidden;
-        if (kind == kWallSpot) return &scene->world.wallSpots[i].hidden;
         if (kind == kGravity) return &scene->world.gravity[i].hidden;
         return nullptr;
     }
@@ -3347,7 +3342,6 @@ struct Studio {
             static const char* shape[] = {"box", "sphere", "capsule", "mesh"};
             return (c.name.empty() ? std::string("surface ") + std::to_string(i + 1) : c.name) + " (" + shape[std::clamp(c.kind, 0, 3)] + ")";
         }
-        if (kind == kWallSpot) { const WorldWallSpot& ws = scene->world.wallSpots[i]; return ws.name.empty() ? "wall spot " + std::to_string(i + 1) : ws.name; }
         if (kind == kGravity) {
             const WorldGravity& g = scene->world.gravity[i];
             return (g.name.empty() ? "gravity " + std::to_string(i + 1) : g.name) + " (" + kGravityNames[std::clamp(g.kind, 0, 2)] + ")";
@@ -3370,7 +3364,6 @@ struct Studio {
             std::memcpy(m, c.world, 64);
             return true;
         }
-        if (kind == kWallSpot) { std::memcpy(m, scene->world.wallSpots[i].world, 64); return true; }
         if (kind == kGravity) { std::memcpy(m, scene->world.gravity[i].world, 64); return true; }
         return false;
     }
@@ -3399,13 +3392,6 @@ struct Studio {
             if (c.kind == WorldCollider::Box) for (int k = 0; k < 3; ++k) c.half[k] = std::max(0.01f, b.half[k] * sc[k]);
             else if (c.kind == WorldCollider::Sphere) c.radius = std::max(0.01f, b.radius * (sc[0] + sc[1] + sc[2]) / 3);
             else { c.radius = std::max(0.01f, b.radius * (sc[0] + sc[2]) * 0.5f); c.length = std::max(0.0f, b.length * sc[1]); }
-        } else if (kind == kWallSpot) {
-            WorldWallSpot& ws = scene->world.wallSpots[i];
-            const WorldWallSpot& b = i < static_cast<int>(dragBase.wallSpots.size()) ? dragBase.wallSpots[i] : ws;
-            float sc[3];
-            unscale(m, ws.world, sc);
-            ws.width = std::max(0.05f, b.width * sc[0]);
-            ws.height = std::max(0.05f, b.height * sc[1]);
         } else if (kind == kGravity) {   // scaling resizes the region (box) or the pull (planet)
             WorldGravity& g = scene->world.gravity[i];
             const WorldGravity& b = i < static_cast<int>(dragBase.gravity.size()) ? dragBase.gravity[i] : g;
@@ -3500,11 +3486,6 @@ struct Studio {
             wIndex = combineTouching(static_cast<int>(w.colliders.size()) - 1);
             selected = -1;
             return;
-        } else if (kind == kWallSpot) {
-            WorldWallSpot ws;
-            ws.name = "Wall spot " + std::to_string(w.wallSpots.size() + 1);
-            translation(ws.world, x, y + 1.4f, z);
-            w.wallSpots.push_back(ws);
         }
         wKind = kind;
         wIndex = worldCount(kind) - 1;
@@ -3513,7 +3494,7 @@ struct Studio {
 
     // Points the camera at a world item (double-click in the explorer, F).
     void frameWorld(int kind, int i) {
-        float m[16], mn[3], mx[3];
+        float mn[3], mx[3];
         if (WorldPoint* p = worldPoint(kind, i)) {
             for (int k = 0; k < 3; ++k) { mn[k] = p->pos[k] - 1; mx[k] = p->pos[k] + 1; }
         } else if (kind == kCollider) {
@@ -3532,10 +3513,6 @@ struct Studio {
             const WorldGravity& g = scene->world.gravity[i];
             const float r = g.kind == WorldGravity::Planet ? g.radius : std::max({g.half[0], g.half[1], g.half[2]});
             for (int k = 0; k < 3; ++k) { mn[k] = g.world[12 + k] - r; mx[k] = g.world[12 + k] + r; }
-        } else if (kind == kWallSpot && worldMatrix(kind, i, m)) {
-            const WorldWallSpot& ws = scene->world.wallSpots[i];
-            const float r = std::max(ws.width, ws.height) * 0.5f;
-            for (int k = 0; k < 3; ++k) { mn[k] = m[12 + k] - r; mx[k] = m[12 + k] + r; }
         } else return;
         frameBounds(mn, mx);
     }
@@ -3556,7 +3533,6 @@ struct Studio {
             case kSeat: w.seats.erase(w.seats.begin() + wIndex); break;
             case kHotspot: w.hotspots.erase(w.hotspots.begin() + wIndex); break;
             case kCollider: w.colliders.erase(w.colliders.begin() + wIndex); break;
-            case kWallSpot: w.wallSpots.erase(w.wallSpots.begin() + wIndex); break;
             case kGravity: w.gravity.erase(w.gravity.begin() + wIndex); break;
         }
         if (isolating && isoKind == wKind) {   // keep Show Only Selected on the same item (or end it with it)
@@ -4715,7 +4691,7 @@ struct Studio {
                 }
             }
         }
-        // World: the home's spawns, seats, hotspots, walls and wall spots (Studio's own format, from Meta's when converted).
+        // World: the home's spawns, seats, hotspots and walls (Studio's own format, from Meta's when converted).
         if (scene && !objects.empty()) {
             int total = 0;
             for (int k = 0; k < kWorldKinds; ++k) total += worldCount(k);
@@ -5014,16 +4990,6 @@ struct Studio {
                     if (c.kind == WorldCollider::Sphere || c.kind == WorldCollider::Capsule) { fieldLabel("Radius"); ImGui::DragFloat("##wrad", &c.radius, 0.01f, 0.01f, 50.0f, "%.2f m"); track(); }
                     if (c.kind == WorldCollider::Capsule) { fieldLabel("Length"); ImGui::DragFloat("##wlen", &c.length, 0.01f, 0.0f, 50.0f, "%.2f m"); track(); }
                 }
-            } else if (wKind == kWallSpot) {
-                WorldWallSpot& ws = scene->world.wallSpots[wIndex];
-                float t[3], r[3], sc[3];
-                ImGuizmo::DecomposeMatrixToComponents(ws.world, t, r, sc);
-                bool moved = false;
-                fieldLabel("Location"); moved |= ImGui::DragFloat3("##wsloc", t, 0.01f, 0, 0, "%.2f m"); track();
-                fieldLabel("Rotation"); tidyZero(r, 0.001f); moved |= ImGui::DragFloat3("##wsrot", r, 0.5f, 0, 0, "%.0f\u00b0"); track();
-                if (moved) { sc[0] = sc[1] = sc[2] = 1; ImGuizmo::RecomposeMatrixFromComponents(t, r, sc, ws.world); }
-                fieldLabel("Width"); ImGui::DragFloat("##wwid", &ws.width, 0.01f, 0.1f, 20.0f, "%.2f m"); track();
-                fieldLabel("Height"); ImGui::DragFloat("##whei", &ws.height, 0.01f, 0.1f, 20.0f, "%.2f m"); track();
             }
             if (wKind == kGravity) {
                 WorldGravity& g = scene->world.gravity[wIndex];
@@ -5569,7 +5535,7 @@ struct Studio {
     }
 
     // The world layer drawn over the 3D view (x-ray: always visible): spawns cyan, seats green, hotspots yellow,
-    // walls red (triggers dim), wall spots blue, walkable areas green. The selected item is drawn brighter.
+    // walls red (triggers dim), walkable areas green. The selected item is drawn brighter.
     void drawWorld(ImDrawList* dl, const float* viewProj) {
         if (!scene || !showWorld) return;
         const HomeWorld& w = scene->world;
@@ -5778,15 +5744,6 @@ struct Studio {
                 x += (k ? ww : wf) + gap * 1.4f;
             }
         }
-        for (size_t i = 0; i < w.wallSpots.size(); ++i) {
-            if (!worldShown(kWallSpot, static_cast<int>(i))) continue;
-            const WorldWallSpot& ws = w.wallSpots[i];
-            const bool sel = wKind == kWallSpot && wIndex == static_cast<int>(i), hov = hoverKind == kWallSpot && hoverIndex == static_cast<int>(i);
-            float v[4][3];
-            const float hw = ws.width * 0.5f, hh = ws.height * 0.5f;
-            xf(ws.world, -hw, -hh, 0, v[0]); xf(ws.world, hw, -hh, 0, v[1]); xf(ws.world, hw, hh, 0, v[2]); xf(ws.world, -hw, hh, 0, v[3]);
-            for (int k = 0; k < 4; ++k) line(v[k], v[(k + 1) % 4], hov && !sel ? col(0xfff2b0) : col(0x5b8def, sel ? 1.0f : 0.8f), sel || hov ? th * 2 : th);
-        }
         // Gravity zones: the region, and arrows showing which way is down.
         for (size_t i = 0; i < w.gravity.size(); ++i) {
             if (!worldShown(kGravity, static_cast<int>(i))) continue;
@@ -5848,8 +5805,8 @@ struct Studio {
     }
 
     // The world item under a click: points and shape centres within a few pixels.
-    // The world item under a viewport pixel: a wall or surface box anywhere on it (a placed mesh on its triangles, a
-    // wall spot on its panel), a spawn, seat or hotspot within a finger's width of its marker (seats: the chair drawn),
+    // The world item under a viewport pixel: a wall or surface box anywhere on it (a placed mesh on its triangles),
+    // a spawn, seat or hotspot within a finger's width of its marker (seats: the chair drawn),
     // a gravity zone at its centre. Markers win over a box they're in front of. hit: the point grabbed (dragging keeps
     // it under the mouse).
     bool worldUnder(float mx, float my, const float* viewProj, int& kind, int& index, float hit[3]) {
@@ -5910,13 +5867,6 @@ struct Studio {
             }
             if (ok && t < bestT) { bestT = t; vk = kCollider; vi = static_cast<int>(i); }
         }
-        for (size_t i = 0; i < w.wallSpots.size(); ++i) {               // the panel's rectangle
-            const WorldWallSpot& ws = w.wallSpots[i];
-            if (!worldShown(kWallSpot, static_cast<int>(i))) continue;
-            const float h[3] = {ws.width * 0.5f, ws.height * 0.5f, 0.05f};
-            float t;
-            if (boxHit(ws.world, h, t) && t < bestT) { bestT = t; vk = kWallSpot; vi = static_cast<int>(i); }
-        }
         // markers: the nearest on screen within reach, unless a shape is well in front of it
         float bestPx = 20 * scale, depth = 0;
         int pk = -1, pi = -1;
@@ -6679,8 +6629,6 @@ struct Studio {
         if (ImGui::IsItemHovered()) ImGui::SetTooltip("A 2 x 2 m box: scale it into a floor, a step or a wall");
         if (ImGui::MenuItem("Invisible Wall", nullptr, false, on)) addInvisibleWall();
         if (ImGui::IsItemHovered()) ImGui::SetTooltip("Stops the player, never drawn on the headset. Scale and turn it to fit;\nwhere it stands is no longer walkable.");
-        if (ImGui::MenuItem("Wall Spot", nullptr, false, on)) addWorld(kWallSpot);
-        if (ImGui::IsItemHovered()) ImGui::SetTooltip("Where SteamVR's panels dock");
         ImGui::Separator();
         if (ImGui::BeginMenu("Gravity Zone", on)) {
             if (ImGui::MenuItem("Direction")) addGravity(WorldGravity::Direction);
@@ -7222,7 +7170,6 @@ struct Studio {
             {"Add Teleport Hotspot", "", on, [this] { addWorld(kHotspot); }},
             {"Add Surface", "", on, [this] { addWorld(kCollider); }},
             {"Add Invisible Wall", "", on, [this] { addInvisibleWall(); }},
-            {"Add Wall Spot", "", on, [this] { addWorld(kWallSpot); }},
             {"Add Gravity Zone", "", on, [this] { addGravity(WorldGravity::Direction); }},
             {"Import Models", "", on && !uploading, [this] { importModelDialog(); }},
             {"Add Vista", "", on && homePaths.size() == 1, [this] { addVistaDialog(); }},
@@ -8733,20 +8680,19 @@ struct SelfTest {
                           r.spawnAdded ? "added" : "kept");
             check(r.ok && r.walk.walkArea > 1 && a.walkSaved() && autos == r.objects + r.colliders && r.objects > 0 && r.colliders > 0, "Auto-generate bakes the walkable area and saves it with the home", d);
             check(a.surfaceMode(a.objects[obj]) == kSurfSolid && !a.autoMade(a.objects[obj]), "...and keeps the surface set by hand");
-            {   // the world items: walls (Wall-role boxes), objects' collision (meshes) and wall spots; no seats or hotspots
-                int walls = 0, objs = 0, seats = 0, spots = 0, hots = 0;
+            {   // the world items: walls (Wall-role boxes) and objects' collision (meshes); no seats or hotspots
+                int walls = 0, objs = 0, seats = 0, hots = 0;
                 for (const WorldCollider& c : a.scene->world.colliders) {
                     walls += c.name == "Auto wall" && c.role == WorldCollider::Wall && c.kind == WorldCollider::Box;
                     objs += (c.name.rfind("Auto surface", 0) == 0 && c.role == WorldCollider::Solid) || (c.name.rfind("Auto collider", 0) == 0 && c.role == WorldCollider::Object);
                 }
                 for (const WorldPoint& p : a.scene->world.seats) seats += p.name == "Auto seat";
-                for (const WorldWallSpot& p : a.scene->world.wallSpots) spots += p.name == "Auto wall spot";
                 for (const WorldPoint& p : a.scene->world.hotspots) hots += p.name == "Auto hotspot";
-                check(walls == 0 && r.walls == 0 && objs == r.objects + r.colliders && r.objects > 0 && spots == 0 && seats == 0 && hots == 0,
-                      "...and makes floor meshes surfaces and the other objects colliders (no walls, wall spots, seats or hotspots)",
-                      std::to_string(r.objects) + " surfaces, " + std::to_string(r.colliders) + " colliders, " + std::to_string(spots) + " wall spots, " + std::to_string(seats) +
+                check(walls == 0 && r.walls == 0 && objs == r.objects + r.colliders && r.objects > 0 && seats == 0 && hots == 0,
+                      "...and makes floor meshes surfaces and the other objects colliders (no walls, seats or hotspots)",
+                      std::to_string(r.objects) + " surfaces, " + std::to_string(r.colliders) + " colliders, " + std::to_string(seats) +
                           " seats, " + std::to_string(hots) + " hotspots");
-                genCounts = {walls, objs, spots, seats + hots};   // (objs: surfaces + colliders)
+                genCounts = {walls, objs, seats + hots};   // (objs: surfaces + colliders)
                 collidersAfter = a.scene->world.colliders.size();
             }
             firstGrid = a.scene->world.walkGrid;
@@ -8798,7 +8744,7 @@ struct SelfTest {
             for (const WorldPoint& p : a.scene->world.spawns) autoSpawns += p.name == "Auto spawn";
             const auto& r = a.autoReport;
             check(r.ok && a.scene->world.walkGrid == firstGrid && autoSpawns <= 1 && a.scene->world.colliders.size() == collidersAfter &&
-                  std::array<int, 4>{r.walls, r.objects + r.colliders, r.spots, r.seats + r.hotspots} == genCounts,
+                  std::array<int, 3>{r.walls, r.objects + r.colliders, r.seats + r.hotspots} == genCounts,
                   "re-running gives the same area and items (no duplicate spawns, surfaces, walls or objects)", std::to_string(a.scene->world.spawns.size()) + " spawns");
             if (a.autoUndoAt.x >= 0) click(a.autoUndoAt);   // the summary's Undo: just this run
             return 4;
@@ -9229,7 +9175,7 @@ struct SelfTest {
     float invisibleWallAt[3] = {};                     // the invisible-wall test's spot (on the spawn's floor)
     size_t libraryBefore = 0;                          // My Environments' count before the bundle is unpacked into it
     std::string titleWas, imageWas;
-    std::array<int, 4> genCounts{};                    // Auto-generate's walls, objects, wall spots, seats + hotspots (first run)
+    std::array<int, 3> genCounts{};                    // Auto-generate's walls, objects, seats + hotspots (first run)
     size_t collidersAfter = 0;
     size_t linkedBefore = 0;                           // mesh-linked surfaces before Make Walkable Floors (the home links its own)          // the background-sound test's files (removed when it ends)
 
diff --git a/third_party/qhe/core/world.h b/third_party/qhe/core/world.h
index 23ba11f..238d964 100644
--- a/third_party/qhe/core/world.h
+++ b/third_party/qhe/core/world.h
@@ -1,7 +1,7 @@
 #pragma once
 // A home's world layer: where the player stands and can go — the parts of Meta's environment system that are not
 // drawn. Converted from Meta's components (SpawnPoint, AvatarSitting, LocomotionHotspot, Collider Box / Sphere /
-// Capsule / Mesh / ConvexMesh, WallPlacement) into one plain format that a .fenv stores as world.json, Frame Studio
+// Capsule / Mesh / ConvexMesh) into one plain format that a .fenv stores as world.json, Frame Studio
 // edits and Frame Home uses for the floor, the start position, walking, teleporting and sitting.
 // Everything is in world space, metres, +Y up.
 #include "core/tinyjson.h"
@@ -52,13 +52,6 @@ struct WorldCollider {
     bool trigger() const { return role == Trigger; }
 };
 
-struct WorldWallSpot {                  // where a panel or window can hang (WallPlacementComponent)
-    std::string name;
-    float world[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
-    float width = 1, height = 1;
-    bool hidden = false;                // Frame Studio's view only
-};
-
 // Which way is down. Without zones it's -Y everywhere (Meta's homes); a zone changes it inside its region:
 //   Direction: down is the zone frame's -Y — a room where a wall is the floor, a ceiling walk
 //   Planet:    down points at the zone's centre, within `radius` of it — walk all the way round a sphere
@@ -84,13 +77,12 @@ struct HomeWorld {
     std::vector<WorldCollider> colliders;
     std::vector<float> walkPositions;   // legacy walkable triangles (v1 files): read as one walkable-floor area
     std::vector<u32> walkIndices;
-    std::vector<WorldWallSpot> wallSpots;
     std::vector<WorldGravity> gravity;  // empty: down is -Y everywhere
     float fallLimit = 30;               // falling further than this (metres) puts you back at the spawn
     std::string origin;                 // "meta" (converted), "studio" (edited) or "" (none)
     std::string walkGrid;               // the walkable area Frame Studio baked (walkgrid.h encoding); "": Frame Home bakes one at load
     std::shared_ptr<const WalkGrid> walkGridCache;   // walkGrid decoded, or one just built (never saved)
-    bool empty() const { return spawns.empty() && seats.empty() && hotspots.empty() && colliders.empty() && walkIndices.empty() && wallSpots.empty() && gravity.empty() && walkGrid.empty(); }
+    bool empty() const { return spawns.empty() && seats.empty() && hotspots.empty() && colliders.empty() && walkIndices.empty() && gravity.empty() && walkGrid.empty(); }
 };
 
 namespace world_detail {
@@ -167,15 +159,7 @@ inline std::string worldToJson(const HomeWorld& w) {
     o += "],\n\"walkable\":{\"positions\":"; arr(o, w.walkPositions.data(), w.walkPositions.size());
     o += ",\"indices\":[";
     for (size_t k = 0; k < w.walkIndices.size(); ++k) { if (k) o += ','; o += std::to_string(w.walkIndices[k]); }
-    o += "]},\n\"wallSpots\":[";
-    for (size_t i = 0; i < w.wallSpots.size(); ++i) {
-        const WorldWallSpot& s = w.wallSpots[i];
-        if (i) o += ',';
-        o += "{\"name\":" + q(s.name) + ",\"world\":"; arr(o, s.world, 16); o += ",\"width\":"; num(o, s.width); o += ",\"height\":"; num(o, s.height);
-        if (s.hidden) o += ",\"hidden\":true";
-        o += '}';
-    }
-    o += "],\n\"gravity\":[";
+    o += "]},\n\"gravity\":[";
     for (size_t i = 0; i < w.gravity.size(); ++i) {
         const WorldGravity& g = w.gravity[i];
         if (i) o += ',';
@@ -219,14 +203,6 @@ inline bool worldFromJson(const std::string& json, HomeWorld& w) {
         w.walkPositions.resize(wk["positions"].size());
         readF(wk["positions"], w.walkPositions.data(), w.walkPositions.size());
         for (size_t k = 0; k < wk["indices"].size(); ++k) w.walkIndices.push_back(static_cast<u32>(wk["indices"][k].asFloat()));
-        for (size_t i = 0; i < d["wallSpots"].size(); ++i) {
-            const auto& v = d["wallSpots"][i];
-            WorldWallSpot s;
-            s.name = v["name"].asString(); readF(v["world"], s.world, 16);
-            s.width = static_cast<float>(v["width"].asFloat()); s.height = static_cast<float>(v["height"].asFloat());
-            s.hidden = v["hidden"].boolVal;
-            w.wallSpots.push_back(s);
-        }
         for (size_t i = 0; i < d["gravity"].size(); ++i) {
             const auto& v = d["gravity"][i];
             WorldGravity g;
diff --git a/third_party/qhe/loaders/scene_loader.h b/third_party/qhe/loaders/scene_loader.h
index 6cf6f60..72926b9 100644
--- a/third_party/qhe/loaders/scene_loader.h
+++ b/third_party/qhe/loaders/scene_loader.h
@@ -224,7 +224,7 @@ public:
     // tag "local" = the player start (cyan), "remote" = other spawns (yellow).
     struct SpawnPt { std::string name, tag; float pos[3]={0,0,0}, euler[3]={0,0,0}; int meshIdx=-1; };
     std::vector<SpawnPt> spawnPts;
-    HomeWorld world;                   // spawns, seats, hotspots, colliders, wall spots (world space), from every HSTF
+    HomeWorld world;                   // spawns, seats, hotspots, colliders (world space), from every HSTF
 
     // Whether an HSTF entity draws anything (a MeshPlatformComponent): its colliders are then that thing's.
     static bool entityDrawn(const tinyjson::Value& ent) {
@@ -614,11 +614,6 @@ public:
                             world.seats.push_back(p);
                         } else if (cls.find("LocomotionHotspotComponent") != std::string::npos) {
                             WorldPoint p; point(p); world.hotspots.push_back(p);
-                        } else if (cls.find("WallPlacementComponent") != std::string::npos) {
-                            WorldWallSpot ws; ws.name = name; std::memcpy(ws.world, wm, 64);
-                            ws.width = d.has("propMaxWidth") ? static_cast<float>(d["propMaxWidth"].asFloat()) : 1.0f;
-                            ws.height = d.has("propMaxHeight") ? static_cast<float>(d["propMaxHeight"].asFloat()) : 1.0f;
-                            world.wallSpots.push_back(ws);
                         } else if (cls.find("Collider") != std::string::npos && cls.find("PlatformComponent") != std::string::npos) {
                             WorldCollider col; col.name = name; std::memcpy(col.world, wm, 64); col.role = trigger || hotspot || seat ? WorldCollider::Trigger : WorldCollider::Solid;
                             if (cls.find("ColliderBox") != std::string::npos) {
@@ -813,8 +808,8 @@ public:
             float identMat[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
             loadHstfRec(*spacePath, 6, Transform{}, identMat, HstfDeltas{}, std::string());
             world.origin = world.empty() ? "" : "meta";
-            log("  World: %zu spawns, %zu seats, %zu hotspots, %zu colliders, %zu wall spots", world.spawns.size(), world.seats.size(),
-                world.hotspots.size(), world.colliders.size(), world.wallSpots.size());
+            log("  World: %zu spawns, %zu seats, %zu hotspots, %zu colliders", world.spawns.size(), world.seats.size(),
+                world.hotspots.size(), world.colliders.size());
         }
         // DEDUP empty-transform template duplicates. A mesh defined in a level .usda with NO transform lands
         // at the ORIGIN (it's the PROTOTYPE); a sibling entity of the SAME NAME placed by an .hstf carries the
diff --git a/tools/walktest/walkviz.cpp b/tools/walktest/walkviz.cpp
index ee608ab..4eb0e97 100644
--- a/tools/walktest/walkviz.cpp
+++ b/tools/walktest/walkviz.cpp
@@ -164,8 +164,8 @@ int main(int argc, char** argv) {
             std::printf("   lost cells: %d\n", lost);
             std::printf("   re-baked with the walls and objects: %.1f m2 (was %.1f)\n", r2.walkArea, r.walkArea);
         }
-        std::printf("   generated in %.1f ms: %zu walls, %zu objects, %zu seats, %zu wall spots, %zu hotspots\n", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - t0).count(),
-                    gr.walls.size(), gr.objects.size(), gr.seats.size(), gr.spots.size(), gr.hotspots.size());
+        std::printf("   generated in %.1f ms: %zu walls, %zu objects, %zu seats, %zu hotspots\n", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - t0).count(),
+                    gr.walls.size(), gr.objects.size(), gr.seats.size(), gr.hotspots.size());
         auto line = [&](float x0, float z0, float x1, float z1, int R, int G, int B) {
             const int n = static_cast<int>(std::hypot(x1 - x0, z1 - z0) / g->p.cell * px) + 1;
             for (int i = 0; i <= n; ++i) {
@@ -192,12 +192,6 @@ int main(int argc, char** argv) {
                 const float xa = v[0], xb = v[3], za = v[2], zb = v[14];
                 line(xa, za, xb, za, 40, 160, 255); line(xb, za, xb, zb, 40, 160, 255); line(xb, zb, xa, zb, 40, 160, 255); line(xa, zb, xa, za, 40, 160, 255);
             }
-        for (const WorldWallSpot& w : gr.spots) {
-            const float hx = w.width * 0.5f, ux = w.world[0], uz = w.world[2];
-            line(w.world[12] - ux * hx, w.world[14] - uz * hx, w.world[12] + ux * hx, w.world[14] + uz * hx, 255, 230, 0);
-            line(w.world[12], w.world[14], w.world[12] + w.world[8] * 0.6f, w.world[14] + w.world[10] * 0.6f, 255, 230, 0);
-            std::printf("   wall spot %.1f x %.1f m at (%.2f %.2f %.2f)\n", w.width, w.height, w.world[12], w.world[13], w.world[14]);
-        }
         for (const WorldPoint& p : gr.seats) {
             const float fx = -std::sin(p.yaw), fz = -std::cos(p.yaw);
             line(p.pos[0] - 0.15f, p.pos[2], p.pos[0] + 0.15f, p.pos[2], 255, 0, 255);
diff --git a/tools/walktest/worldrender.cpp b/tools/walktest/worldrender.cpp
index 18f8062..fc63d69 100644
--- a/tools/walktest/worldrender.cpp
+++ b/tools/walktest/worldrender.cpp
@@ -1,6 +1,6 @@
 // Renders a home headlessly (lavapipe: VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.json) with its walkable area
 // and World > Auto-generate's items drawn over it as Frame Studio's guide pass does:
-//   walkable area green, walls red boxes, seats magenta posts + facing bar, wall spots yellow panels, hotspots cyan posts
+//   walkable area green, walls red boxes, seats magenta posts + facing bar, hotspots cyan posts
 // worldrender <apk[+vista]> <out-prefix> [size] [x,y,z,yaw,pitch ...]   (no views: four from above the area's corners)
 #include "hsl_renderer.h"
 #include "hsl_scene.h"
@@ -49,7 +49,7 @@ int main(int argc, char** argv) {
     w.walkGridCache = bakeWalkGrid(scene, w, WalkParams{});
     const WalkGrid& g = *w.walkGridCache;
     const GenResult gen = generateWorldItems(g, w, drawnWalkSources(scene, w, nullptr, nullptr, false));
-    std::printf("%zu walls, %zu seats, %zu wall spots, %zu hotspots\n", gen.walls.size(), gen.seats.size(), gen.spots.size(), gen.hotspots.size());
+    std::printf("%zu walls, %zu seats, %zu hotspots\n", gen.walls.size(), gen.seats.size(), gen.hotspots.size());
 
     std::vector<GuideVertex> v;
     auto vert = [&](const float* p, const float* c) { GuideVertex q; std::memcpy(q.pos, p, 12); std::memcpy(q.rgba, c, 16); v.push_back(q); };
@@ -63,7 +63,7 @@ int main(int argc, char** argv) {
         static const int f[12][3] = {{0,1,3},{0,3,2},{4,6,7},{4,7,5},{0,4,5},{0,5,1},{2,3,7},{2,7,6},{0,2,6},{0,6,4},{1,5,7},{1,7,3}};
         for (auto& t : f) tri(p[t[0]], p[t[1]], p[t[2]], col);
     };
-    const float green[4] = {0.1f, 0.85f, 0.3f, 0.35f}, red[4] = {1, 0.15f, 0.1f, 0.55f}, mag[4] = {1, 0, 1, 0.9f}, yel[4] = {1, 0.9f, 0, 0.6f}, cyan[4] = {0, 0.9f, 1, 0.9f};
+    const float green[4] = {0.1f, 0.85f, 0.3f, 0.35f}, red[4] = {1, 0.15f, 0.1f, 0.55f}, mag[4] = {1, 0, 1, 0.9f}, cyan[4] = {0, 0.9f, 1, 0.9f};
     g.outline([&](const float* a, const float* b, const float* c, bool) {
         const float A[3] = {a[0], a[1] + 0.03f, a[2]}, B[3] = {b[0], b[1] + 0.03f, b[2]}, C[3] = {c[0], c[1] + 0.03f, c[2]};
         tri(A, B, C, green);
@@ -76,7 +76,6 @@ int main(int argc, char** argv) {
         const float m2[16] = {fz,0,-fx,0, 0,1,0,0, fx,0,fz,0, p.pos[0] + fx * 0.2f, p.pos[1] + 0.02f, p.pos[2] + fz * 0.2f, 1}, h2[3] = {0.03f, 0.02f, 0.2f};
         box(m2, h2, mag);
     }
-    for (const WorldWallSpot& s : gen.spots) { const float h[3] = {s.width * 0.5f, s.height * 0.5f, 0.02f}; box(s.world, h, yel); }
     for (const WorldPoint& p : gen.hotspots) {
         const float m[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, p.pos[0], p.pos[1] + 0.75f, p.pos[2], 1}, h[3] = {0.05f, 0.75f, 0.05f};
         box(m, h, cyan);
@@ -123,11 +122,6 @@ int main(int argc, char** argv) {
             const float fx = -std::sin(p.yaw), fz = -std::cos(p.yaw);
             cams.push_back({p.pos[0] + fx * 1.6f, p.pos[1] + 1.1f, p.pos[2] + fz * 1.6f, p.yaw * 57.2958f + 180, -28});
         }
-    if (mode == "spots")                                               // each wall spot from 2.5 m back
-        for (const WorldWallSpot& w : gen.spots) {
-            const float fx = w.world[8], fz = w.world[10];
-            cams.push_back({w.world[12] + fx * 2.5f, w.world[13], w.world[14] + fz * 2.5f, std::atan2(fx, fz) * 57.2958f, 0});
-        }
     if (cams.empty() && mode.empty()) {   // an overview from high over the area, then eye-level views from spots across it, both ways
         float lo[2] = {1e9f, 1e9f}, hi[2] = {-1e9f, -1e9f}, y = 0; int n = 0;
         for (int z = 0; z < g.nz; ++z) for (int x = 0; x < g.nx; ++x) for (const WalkSpan* s = g.begin(x, z); s != g.end(x, z); ++s)