diff --git a/assets/static/index.html b/assets/static/index.html
index b7f0dbf..e200e09 100644
--- a/assets/static/index.html
+++ b/assets/static/index.html
@@ -413,7 +413,6 @@
                 <div class="radar3d-controls">
                     <button id="radar3d-reset" disabled>Reset View</button>
                     <button id="radar3d-auto-rotate" disabled>Auto Rotate</button>
-                    <button id="radar3d-trails" disabled>Show Trails</button>
                     <label>
                         <input type="range" id="radar3d-range" min="10" max="500" value="100" disabled>
                         Range: <span id="radar3d-range-value">100</span> km
diff --git a/assets/static/js/app.js b/assets/static/js/app.js
index 836feb0..e81b62f 100644
--- a/assets/static/js/app.js
+++ b/assets/static/js/app.js
@@ -9,184 +9,6 @@ import { MapManager } from './modules/map-manager.js?v=2';
 import { UIManager } from './modules/ui-manager.js?v=2';
 import { CallsignManager } from './modules/callsign-manager.js';
 
-// Tile Management for 3D Map Base
-class TileManager {
-    constructor(scene, origin) {
-        this.scene = scene;
-        this.origin = origin;
-        this.loadedTiles = new Map();
-        this.zoom = 12; // OSM zoom level
-        
-        // Calculate tile bounds around origin
-        this.originTileX = this.lonToTileX(origin.longitude, this.zoom);
-        this.originTileY = this.latToTileY(origin.latitude, this.zoom);
-        
-        // Calculate actual tile size based on Web Mercator projection at this latitude
-        this.tileSize = this.calculateTileSize(origin.latitude, this.zoom);
-    }
-    
-    // Calculate the ground size of a tile at given latitude and zoom
-    calculateTileSize(latitude, zoom) {
-        // Earth's circumference at equator in km
-        const earthCircumference = 40075.016686;
-        // Circumference at given latitude
-        const latCircumference = earthCircumference * Math.cos(latitude * Math.PI / 180);
-        // Size of one tile at this latitude and zoom level
-        return latCircumference / Math.pow(2, zoom);
-    }
-    
-    // Convert longitude to OSM tile X coordinate
-    lonToTileX(lon, zoom) {
-        return Math.floor((lon + 180) / 360 * Math.pow(2, zoom));
-    }
-    
-    // Convert latitude to OSM tile Y coordinate  
-    latToTileY(lat, zoom) {
-        return Math.floor((1 - Math.log(Math.tan(lat * Math.PI / 180) + 1 / Math.cos(lat * Math.PI / 180)) / Math.PI) / 2 * Math.pow(2, zoom));
-    }
-    
-    // Convert tile coordinates to world position relative to origin
-    tileToWorldPosition(tileX, tileY) {
-        // Use precise positioning based on actual Web Mercator coordinates
-        const originLon = this.tileXToLon(this.originTileX, this.zoom);
-        const originLat = this.tileYToLat(this.originTileY, this.zoom);
-        const tileLon = this.tileXToLon(tileX, this.zoom);
-        const tileLat = this.tileYToLat(tileY, this.zoom);
-        
-        // Convert to world coordinates using precise geographic distance
-        const deltaX = (tileLon - originLon) * 111320 * Math.cos(this.origin.latitude * Math.PI / 180) / 1000;
-        const deltaZ = -(tileLat - originLat) * 111320 / 1000; // Negative for Three.js coordinates
-        
-        return { x: deltaX, z: deltaZ };
-    }
-    
-    // Convert OSM tile X to longitude
-    tileXToLon(x, zoom) {
-        return x / Math.pow(2, zoom) * 360 - 180;
-    }
-    
-    // Convert OSM tile Y to latitude
-    tileYToLat(y, zoom) {
-        const n = Math.PI - 2 * Math.PI * y / Math.pow(2, zoom);
-        return 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
-    }
-    
-    async loadTile(tileX, tileY) {
-        const key = `${tileX}_${tileY}`;
-        if (this.loadedTiles.has(key)) return;
-        
-        try {
-            // OpenStreetMap tile server
-            const url = `https://tile.openstreetmap.org/${this.zoom}/${tileX}/${tileY}.png`;
-            
-            const texture = await new THREE.TextureLoader().loadAsync(url);
-            // Use ClampToEdgeWrapping to prevent gaps and improve alignment
-            texture.wrapS = texture.wrapT = THREE.ClampToEdgeWrapping;
-            texture.magFilter = THREE.LinearFilter;
-            texture.minFilter = THREE.LinearFilter;
-            
-            // Create tile geometry with exact size for precise alignment
-            const geometry = new THREE.PlaneGeometry(this.tileSize, this.tileSize);
-            const material = new THREE.MeshBasicMaterial({ 
-                map: texture,
-                transparent: false, // Remove transparency to avoid visual artifacts
-                side: THREE.FrontSide
-            });
-            
-            const tile = new THREE.Mesh(geometry, material);
-            tile.rotation.x = -Math.PI / 2; // Lay flat on ground
-            
-            // Position tile relative to origin with precise positioning
-            const worldPos = this.tileToWorldPosition(tileX, tileY);
-            tile.position.set(worldPos.x, 0.01, worldPos.z); // Slightly above ground (1cm)
-            
-            this.scene.add(tile);
-            this.loadedTiles.set(key, tile);
-            
-            if (window.skyviewVerbose) {
-                console.log(`Loaded tile ${tileX},${tileY} at position ${worldPos.x},${worldPos.z}`);
-            }
-            
-        } catch (error) {
-            console.warn(`Failed to load tile ${tileX},${tileY}:`, error);
-        }
-    }
-    
-    async loadInitialTiles() {
-        // Load a larger grid of tiles around the origin for better coverage
-        const tileRange = 3; // Load 3 tiles in each direction (7x7 = ~70km x 70km)
-        
-        // Load center tiles first, then expand outward for better user experience
-        const loadOrder = [];
-        for (let distance = 0; distance <= tileRange; distance++) {
-            for (let x = -distance; x <= distance; x++) {
-                for (let y = -distance; y <= distance; y++) {
-                    if (Math.abs(x) === distance || Math.abs(y) === distance) {
-                        loadOrder.push({ x, y });
-                    }
-                }
-            }
-        }
-        
-        // Load tiles with small delays to avoid overwhelming the server
-        for (const { x, y } of loadOrder) {
-            const tileX = this.originTileX + x;
-            const tileY = this.originTileY + y;
-            await this.loadTile(tileX, tileY);
-            
-            // Small delay to prevent rate limiting
-            if (loadOrder.length > 10) {
-                await new Promise(resolve => setTimeout(resolve, 50));
-            }
-        }
-        
-        // Add origin indicator
-        this.addOriginIndicator();
-    }
-    
-    addOriginIndicator() {
-        // Create a visible marker at the origin point
-        const originGeometry = new THREE.CylinderGeometry(0.5, 0.5, 2, 8);
-        const originMaterial = new THREE.MeshLambertMaterial({ 
-            color: 0xff0000,
-            emissive: 0x440000
-        });
-        const originMarker = new THREE.Mesh(originGeometry, originMaterial);
-        originMarker.position.set(0, 1, 0); // Position at origin, 1km above ground
-        this.scene.add(originMarker);
-        
-        // Add ring indicator on ground
-        const ringGeometry = new THREE.RingGeometry(2, 3, 16);
-        const ringMaterial = new THREE.MeshBasicMaterial({ 
-            color: 0xff0000, 
-            side: THREE.DoubleSide,
-            transparent: true,
-            opacity: 0.7
-        });
-        const originRing = new THREE.Mesh(ringGeometry, ringMaterial);
-        originRing.rotation.x = -Math.PI / 2; // Lay flat on ground
-        originRing.position.set(0, 0.1, 0); // Slightly above ground to prevent z-fighting
-        this.scene.add(originRing);
-        
-        if (window.skyviewVerbose) {
-            console.log('Added origin indicator at (0, 0, 0)');
-        }
-    }
-    
-    // Cleanup method for removing tiles
-    removeTile(tileX, tileY) {
-        const key = `${tileX}_${tileY}`;
-        const tile = this.loadedTiles.get(key);
-        if (tile) {
-            this.scene.remove(tile);
-            tile.geometry.dispose();
-            tile.material.map?.dispose();
-            tile.material.dispose();
-            this.loadedTiles.delete(key);
-        }
-    }
-}
-
 class SkyView {
     constructor() {
         // Initialize managers
@@ -560,8 +382,8 @@ class SkyView {
             
             // Initialize 3D radar when switching to 3D radar view
             if (viewId === 'radar3d-view' && !this.radar3dInitialized) {
-                setTimeout(async () => {
-                    await this.initialize3DRadar();
+                setTimeout(() => {
+                    this.initialize3DRadar();
                     this.radar3dInitialized = true;
                 }, 100); // Small delay to ensure the view is visible
             }
@@ -571,7 +393,7 @@ class SkyView {
     }
 
     // 3D Radar (basic implementation)
-    async initialize3DRadar() {
+    initialize3DRadar() {
         if (this.verbose) {
             console.log('🚀 Starting 3D radar initialization');
         }
@@ -635,11 +457,7 @@ class SkyView {
                     camera: new THREE.PerspectiveCamera(75, width / height, 0.1, 1000),
                     renderer: new THREE.WebGLRenderer({ alpha: true, antialias: true }),
                     controls: null,
-                    aircraftMeshes: new Map(),
-                    aircraftLabels: new Map(),
-                    labelContainer: null,
-                    aircraftTrails: new Map(),
-                    showTrails: false
+                    aircraftMeshes: new Map()
                 };
                 
                 // Set up renderer with forced dimensions
@@ -651,11 +469,7 @@ class SkyView {
                     camera: new THREE.PerspectiveCamera(75, container.clientWidth / container.clientHeight, 0.1, 1000),
                     renderer: new THREE.WebGLRenderer({ alpha: true, antialias: true }),
                     controls: null,
-                    aircraftMeshes: new Map(),
-                    aircraftLabels: new Map(),
-                    labelContainer: null,
-                    aircraftTrails: new Map(),
-                    showTrails: false
+                    aircraftMeshes: new Map()
                 };
                 
                 // Set up renderer
@@ -684,17 +498,6 @@ class SkyView {
             this.radar3d.renderer.setClearColor(0x0a0a0a, 0.9);
             container.appendChild(this.radar3d.renderer.domElement);
             
-            // Create label container for aircraft labels
-            this.radar3d.labelContainer = document.createElement('div');
-            this.radar3d.labelContainer.style.position = 'absolute';
-            this.radar3d.labelContainer.style.top = '0';
-            this.radar3d.labelContainer.style.left = '0';
-            this.radar3d.labelContainer.style.width = '100%';
-            this.radar3d.labelContainer.style.height = '100%';
-            this.radar3d.labelContainer.style.pointerEvents = 'none';
-            this.radar3d.labelContainer.style.zIndex = '1000';
-            container.appendChild(this.radar3d.labelContainer);
-            
             if (this.verbose) {
                 console.log('✅ Renderer added to container');
             }
@@ -712,8 +515,8 @@ class SkyView {
             hemiLight.position.set(0, 100, 0);
             this.radar3d.scene.add(hemiLight);
             
-            // Set up camera with better view of larger map area
-            this.radar3d.camera.position.set(0, 80, 80);
+            // Set up camera
+            this.radar3d.camera.position.set(0, 50, 50);
             this.radar3d.camera.lookAt(0, 0, 0);
             
             // Add controls
@@ -734,7 +537,7 @@ class SkyView {
             }
             
             // Store default camera position for reset functionality
-            this.radar3d.defaultPosition = { x: 0, y: 80, z: 80 };
+            this.radar3d.defaultPosition = { x: 0, y: 50, z: 50 };
             this.radar3d.defaultTarget = { x: 0, y: 0, z: 0 };
             
             // Auto-rotate state
@@ -743,21 +546,31 @@ class SkyView {
             // Origin coordinates (will be fetched from server)
             this.radar3d.origin = { latitude: 59.9081, longitude: 10.8015 }; // fallback
             
-            // Initialize raycaster for click interactions
-            this.radar3d.raycaster = new THREE.Raycaster();
-            this.radar3d.mouse = new THREE.Vector2();
-            this.radar3d.selectedAircraft = null;
-            
             // Initialize 3D controls and fetch origin
             this.initialize3DControls();
             this.fetch3DOrigin();
             
-            // Add click event listener for aircraft selection
-            this.radar3d.renderer.domElement.addEventListener('click', (event) => this.handle3DClick(event));
+            // Add ground plane with better visibility
+            const groundGeometry = new THREE.PlaneGeometry(400, 400);
+            const groundMaterial = new THREE.MeshLambertMaterial({ 
+                color: 0x1a3d2a, 
+                transparent: true, 
+                opacity: 0.8 
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            this.radar3d.scene.add(ground);
             
-            // Initialize map tiles instead of simple ground plane
-            this.radar3d.tileManager = new TileManager(this.radar3d.scene, this.radar3d.origin);
-            await this.radar3d.tileManager.loadInitialTiles();
+            // Add grid with better visibility
+            const gridHelper = new THREE.GridHelper(400, 40, 0x44aa44, 0x44aa44);
+            this.radar3d.scene.add(gridHelper);
+            
+            // Add some reference objects to help with debugging
+            const cubeGeometry = new THREE.BoxGeometry(2, 2, 2);
+            const cubeMaterial = new THREE.MeshLambertMaterial({ color: 0xff0000 });
+            const cube = new THREE.Mesh(cubeGeometry, cubeMaterial);
+            cube.position.set(10, 1, 10);
+            this.radar3d.scene.add(cube);
             
             if (this.verbose) {
                 console.log('3D Radar initialized successfully', {
@@ -801,33 +614,16 @@ class SkyView {
                     if (!this.radar3d.aircraftMeshes.has(key)) {
                         // Create new aircraft mesh only if within range
                         if (withinRange) {
-                            const { geometry, material } = this.create3DAircraftGeometry(aircraft);
+                            const geometry = new THREE.ConeGeometry(0.5, 2, 6);
+                            const material = new THREE.MeshLambertMaterial({ color: 0x00ff00 });
                             const mesh = new THREE.Mesh(geometry, material);
-                            
-                            // Apply signal quality visual effects
-                            this.apply3DSignalQualityEffects(mesh, aircraft);
-                            
                             this.radar3d.aircraftMeshes.set(key, mesh);
                             this.radar3d.scene.add(mesh);
-                            
-                            // Create aircraft label
-                            this.create3DAircraftLabel(key, aircraft);
-                            
-                            // Create trail if trails are enabled
-                            if (this.radar3d.showTrails) {
-                                this.create3DAircraftTrail(key, aircraft);
-                            }
                         }
                     } else {
                         // Aircraft mesh exists, check if it should be visible
                         const mesh = this.radar3d.aircraftMeshes.get(key);
                         mesh.visible = withinRange;
-                        
-                        // Update label visibility
-                        const label = this.radar3d.aircraftLabels.get(key);
-                        if (label) {
-                            label.style.display = withinRange ? 'block' : 'none';
-                        }
                     }
                     
                     // Update position if aircraft is within range
@@ -841,39 +637,19 @@ class SkyView {
                         
                         mesh.position.set(x, y, z);
                         
-                        // Update aircraft visual indicators (direction, climb/descent)
-                        this.update3DAircraftVisuals(mesh, aircraft);
-                        
-                        // Update signal quality effects
-                        this.apply3DSignalQualityEffects(mesh, aircraft);
-                        
-                        // Update trail if trails are enabled
-                        if (this.radar3d.showTrails && aircraft.position_history) {
-                            this.update3DAircraftTrail(key, aircraft);
+                        // Orient mesh based on track
+                        if (aircraft.Track !== undefined) {
+                            mesh.rotation.y = -aircraft.Track * Math.PI / 180;
                         }
                     }
                 }
             });
             
-            // Remove old aircraft and their labels
+            // Remove old aircraft
             this.radar3d.aircraftMeshes.forEach((mesh, key) => {
                 if (!this.aircraftManager.aircraftData.has(key)) {
                     this.radar3d.scene.remove(mesh);
                     this.radar3d.aircraftMeshes.delete(key);
-                    
-                    // Remove associated label
-                    const label = this.radar3d.aircraftLabels.get(key);
-                    if (label) {
-                        this.radar3d.labelContainer.removeChild(label);
-                        this.radar3d.aircraftLabels.delete(key);
-                    }
-                    
-                    // Remove associated trail
-                    const trail = this.radar3d.aircraftTrails.get(key);
-                    if (trail) {
-                        this.radar3d.scene.remove(trail);
-                        this.radar3d.aircraftTrails.delete(key);
-                    }
                 }
             });
         } catch (error) {
@@ -891,663 +667,6 @@ class SkyView {
         }
         
         this.radar3d.renderer.render(this.radar3d.scene, this.radar3d.camera);
-        
-        // Update aircraft labels after rendering
-        this.update3DAircraftLabels();
-    }
-    
-    create3DAircraftLabel(icao, aircraft) {
-        const label = document.createElement('div');
-        label.style.position = 'absolute';
-        label.style.background = 'rgba(0, 0, 0, 0.8)';
-        label.style.color = 'white';
-        label.style.padding = '4px 8px';
-        label.style.borderRadius = '4px';
-        label.style.fontSize = '12px';
-        label.style.fontFamily = 'monospace';
-        label.style.whiteSpace = 'nowrap';
-        label.style.border = '1px solid rgba(255, 255, 255, 0.3)';
-        label.style.pointerEvents = 'auto';
-        label.style.cursor = 'pointer';
-        label.style.transition = 'opacity 0.3s';
-        label.style.zIndex = '1001';
-        
-        // Create label content
-        this.update3DAircraftLabelContent(label, aircraft);
-        
-        // Add click handler to label
-        label.addEventListener('click', (event) => {
-            event.preventDefault();
-            event.stopPropagation();
-            this.select3DAircraft(icao, aircraft);
-        });
-        
-        this.radar3d.labelContainer.appendChild(label);
-        this.radar3d.aircraftLabels.set(icao, label);
-        
-        return label;
-    }
-    
-    update3DAircraftLabelContent(label, aircraft) {
-        const callsign = aircraft.Callsign || aircraft.Icao || 'N/A';
-        const altitude = aircraft.Altitude ? `${Math.round(aircraft.Altitude)}ft` : 'N/A';
-        const speed = aircraft.GroundSpeed ? `${Math.round(aircraft.GroundSpeed)}kts` : 'N/A';
-        
-        label.innerHTML = `
-            <div style="font-weight: bold;">${callsign}</div>
-            <div style="font-size: 10px; opacity: 0.8;">${altitude} • ${speed}</div>
-        `;
-    }
-    
-    update3DAircraftLabels() {
-        if (!this.radar3d || !this.radar3d.aircraftLabels || !this.aircraftManager) return;
-        
-        // Vector for 3D to screen coordinate conversion
-        const vector = new THREE.Vector3();
-        const canvas = this.radar3d.renderer.domElement;
-        
-        this.radar3d.aircraftLabels.forEach((label, icao) => {
-            const mesh = this.radar3d.aircraftMeshes.get(icao);
-            const aircraft = this.aircraftManager.aircraftData.get(icao);
-            
-            if (mesh && aircraft && mesh.visible) {
-                // Get aircraft world position
-                vector.setFromMatrixPosition(mesh.matrixWorld);
-                
-                // Project to screen coordinates
-                vector.project(this.radar3d.camera);
-                
-                // Check if aircraft is behind camera
-                if (vector.z > 1) {
-                    label.style.display = 'none';
-                    return;
-                }
-                
-                // Convert to screen pixels
-                const x = (vector.x * 0.5 + 0.5) * canvas.clientWidth;
-                const y = (vector.y * -0.5 + 0.5) * canvas.clientHeight;
-                
-                // Position label slightly offset from aircraft position
-                label.style.left = `${x + 10}px`;
-                label.style.top = `${y - 30}px`;
-                label.style.display = 'block';
-                label.style.opacity = '1';
-                
-                // Update label content with current aircraft data
-                this.update3DAircraftLabelContent(label, aircraft);
-            } else {
-                label.style.display = 'none';
-            }
-        });
-    }
-    
-    handle3DClick(event) {
-        if (!this.radar3d || !this.radar3d.raycaster || !this.aircraftManager) return;
-        
-        // Prevent event from propagating to orbit controls
-        event.preventDefault();
-        
-        const canvas = this.radar3d.renderer.domElement;
-        const rect = canvas.getBoundingClientRect();
-        
-        // Calculate mouse position in normalized device coordinates (-1 to +1)
-        this.radar3d.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
-        this.radar3d.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
-        
-        // Update raycaster with camera and mouse position
-        this.radar3d.raycaster.setFromCamera(this.radar3d.mouse, this.radar3d.camera);
-        
-        // Get all visible aircraft meshes
-        const aircraftMeshes = [];
-        this.radar3d.aircraftMeshes.forEach((mesh, icao) => {
-            if (mesh.visible) {
-                mesh.userData.icao = icao; // Store ICAO for identification
-                aircraftMeshes.push(mesh);
-            }
-        });
-        
-        // Check for intersections
-        const intersects = this.radar3d.raycaster.intersectObjects(aircraftMeshes);
-        
-        if (intersects.length > 0) {
-            const selectedMesh = intersects[0].object;
-            const selectedIcao = selectedMesh.userData.icao;
-            const aircraft = this.aircraftManager.aircraftData.get(selectedIcao);
-            
-            if (aircraft) {
-                this.select3DAircraft(selectedIcao, aircraft);
-            }
-        } else {
-            // Clicked on empty space, deselect
-            this.deselect3DAircraft();
-        }
-    }
-    
-    select3DAircraft(icao, aircraft) {
-        // Deselect previous aircraft
-        this.deselect3DAircraft();
-        
-        this.radar3d.selectedAircraft = icao;
-        
-        // Highlight selected aircraft mesh
-        const mesh = this.radar3d.aircraftMeshes.get(icao);
-        if (mesh) {
-            mesh.material.color.setHex(0xff8800); // Orange color for selection
-            mesh.material.emissive.setHex(0x441100); // Subtle glow
-        }
-        
-        // Highlight selected aircraft label
-        const label = this.radar3d.aircraftLabels.get(icao);
-        if (label) {
-            label.style.background = 'rgba(255, 136, 0, 0.9)';
-            label.style.borderColor = 'rgba(255, 136, 0, 0.8)';
-            label.style.transform = 'scale(1.1)';
-        }
-        
-        // Log selection for debugging
-        if (this.verbose) {
-            console.log(`Selected aircraft: ${icao}`, aircraft);
-        }
-        
-        // Trigger aircraft selection in main aircraft manager (for consistency with 2D map)
-        if (this.aircraftManager.onAircraftSelected) {
-            this.aircraftManager.onAircraftSelected(icao, aircraft);
-        }
-    }
-    
-    deselect3DAircraft() {
-        if (!this.radar3d.selectedAircraft) return;
-        
-        const icao = this.radar3d.selectedAircraft;
-        
-        // Reset mesh appearance to original aircraft color
-        const mesh = this.radar3d.aircraftMeshes.get(icao);
-        const aircraft = this.aircraftManager.aircraftData.get(icao);
-        if (mesh && aircraft) {
-            const visualType = this.getAircraftVisualType(aircraft);
-            const originalColor = this.getAircraftColor(aircraft, visualType);
-            mesh.material.color.setHex(originalColor);
-            mesh.material.emissive.setHex(originalColor);
-            mesh.material.emissiveIntensity = 0.1; // Restore original glow
-        }
-        
-        // Reset label appearance
-        const label = this.radar3d.aircraftLabels.get(icao);
-        if (label) {
-            label.style.background = 'rgba(0, 0, 0, 0.8)';
-            label.style.borderColor = 'rgba(255, 255, 255, 0.3)';
-            label.style.transform = 'scale(1)';
-        }
-        
-        this.radar3d.selectedAircraft = null;
-    }
-    
-    create3DAircraftTrail(icao, aircraft) {
-        if (!aircraft.position_history || aircraft.position_history.length < 2) return;
-        
-        // Create line geometry for trail
-        const points = [];
-        const originLat = this.radar3d.origin.latitude;
-        const originLon = this.radar3d.origin.longitude;
-        
-        // Convert position history to 3D world coordinates
-        aircraft.position_history.forEach(pos => {
-            if (pos.lat && pos.lon) {
-                const x = (pos.lon - originLon) * 111320 * Math.cos(pos.lat * Math.PI / 180) / 1000;
-                const z = -(pos.lat - originLat) * 111320 / 1000;
-                const y = (pos.altitude || 0) / 1000; // Use historical altitude from position history
-                points.push(new THREE.Vector3(x, y, z));
-            }
-        });
-        
-        if (points.length < 2) return;
-        
-        // Create enhanced line geometry with gradient colors
-        const geometry = this.create3DTrailGeometry(points, aircraft);
-        
-        // Create material with vertex colors for gradient effect
-        const material = new THREE.LineBasicMaterial({ 
-            vertexColors: true,
-            transparent: true,
-            opacity: 0.8
-        });
-        
-        const trail = new THREE.Line(geometry, material);
-        
-        this.radar3d.scene.add(trail);
-        this.radar3d.aircraftTrails.set(icao, trail);
-        
-        if (this.verbose) {
-            console.log(`Created trail for ${icao} with ${points.length} points`);
-        }
-    }
-    
-    update3DAircraftTrail(icao, aircraft) {
-        if (!aircraft.position_history || aircraft.position_history.length < 2) {
-            // Remove trail if no history
-            const trail = this.radar3d.aircraftTrails.get(icao);
-            if (trail) {
-                this.radar3d.scene.remove(trail);
-                this.radar3d.aircraftTrails.delete(icao);
-            }
-            return;
-        }
-        
-        const trail = this.radar3d.aircraftTrails.get(icao);
-        
-        if (trail) {
-            // Update existing trail
-            const points = [];
-            const originLat = this.radar3d.origin.latitude;
-            const originLon = this.radar3d.origin.longitude;
-            
-            // Convert position history to 3D world coordinates
-            aircraft.position_history.forEach(pos => {
-                if (pos.lat && pos.lon) {
-                    const x = (pos.lon - originLon) * 111320 * Math.cos(pos.lat * Math.PI / 180) / 1000;
-                    const z = -(pos.lat - originLat) * 111320 / 1000;
-                    const y = (pos.altitude || 0) / 1000; // Use historical altitude from position history
-                    points.push(new THREE.Vector3(x, y, z));
-                }
-            });
-            
-            if (points.length >= 2) {
-                // Update geometry with enhanced trail visualization
-                const newGeometry = this.create3DTrailGeometry(points, aircraft);
-                trail.geometry.dispose(); // Clean up old geometry
-                trail.geometry = newGeometry;
-            }
-        } else {
-            // Create new trail
-            this.create3DAircraftTrail(icao, aircraft);
-        }
-    }
-    
-    toggle3DTrails() {
-        this.radar3d.showTrails = !this.radar3d.showTrails;
-        
-        if (this.radar3d.showTrails) {
-            // Create trails for all existing aircraft
-            this.aircraftManager.aircraftData.forEach((aircraft, icao) => {
-                if (this.radar3d.aircraftMeshes.has(icao)) {
-                    this.create3DAircraftTrail(icao, aircraft);
-                }
-            });
-        } else {
-            // Remove all trails
-            this.radar3d.aircraftTrails.forEach((trail, icao) => {
-                this.radar3d.scene.remove(trail);
-            });
-            this.radar3d.aircraftTrails.clear();
-        }
-        
-        // Update button state
-        const trailButton = document.getElementById('radar3d-trails');
-        if (trailButton) {
-            trailButton.textContent = this.radar3d.showTrails ? 'Hide Trails' : 'Show Trails';
-            trailButton.classList.toggle('active', this.radar3d.showTrails);
-        }
-        
-        if (this.verbose) {
-            console.log(`3D trails ${this.radar3d.showTrails ? 'enabled' : 'disabled'}`);
-        }
-    }
-    
-    // Aircraft visual type determination based on category and other data
-    getAircraftVisualType(aircraft) {
-        const category = aircraft.Category || '';
-        
-        // Helicopter detection
-        if (category.toLowerCase().includes('helicopter') || 
-            category.toLowerCase().includes('rotorcraft')) {
-            return 'helicopter';
-        }
-        
-        // Weight-based categories
-        if (category.includes('Heavy')) return 'heavy';
-        if (category.includes('Medium')) return 'medium';  
-        if (category.includes('Light')) return 'light';
-        
-        // Size-based categories (fallback)
-        if (category.includes('Large')) return 'heavy';
-        if (category.includes('Small')) return 'light';
-        
-        // Default to medium commercial aircraft
-        return 'medium';
-    }
-    
-    // Get aircraft color based on type and status
-    getAircraftColor(aircraft, visualType) {
-        // Emergency override
-        if (aircraft.Emergency && aircraft.Emergency !== 'None') {
-            return 0xff0000; // Red for emergencies
-        }
-        
-        // Special squawk codes
-        if (aircraft.Squawk) {
-            if (aircraft.Squawk === '7500' || aircraft.Squawk === '7600' || aircraft.Squawk === '7700') {
-                return 0xff0000; // Red for emergency squawks
-            }
-        }
-        
-        // Type-based colors
-        switch (visualType) {
-            case 'helicopter':
-                return 0x00ffff; // Cyan for helicopters
-            case 'heavy':
-                return 0x0088ff; // Blue for heavy aircraft
-            case 'medium':
-                return 0x00ff00; // Green for medium aircraft (default)
-            case 'light':
-                return 0xffff00; // Yellow for light aircraft
-            default:
-                return 0x00ff00; // Default green
-        }
-    }
-    
-    // Create appropriate 3D geometry and material for aircraft type
-    create3DAircraftGeometry(aircraft) {
-        const visualType = this.getAircraftVisualType(aircraft);
-        const color = this.getAircraftColor(aircraft, visualType);
-        
-        let geometry, scale = 1;
-        
-        switch (visualType) {
-            case 'helicopter':
-                // Helicopter: Wider, flatter shape with rotor disk
-                geometry = new THREE.CylinderGeometry(0.8, 0.4, 0.6, 8);
-                scale = 1.0;
-                break;
-                
-            case 'heavy':
-                // Heavy aircraft: Large, wide fuselage
-                geometry = new THREE.CylinderGeometry(0.4, 0.8, 3.0, 8);
-                scale = 1.3;
-                break;
-                
-            case 'light':
-                // Light aircraft: Small, simple shape
-                geometry = new THREE.ConeGeometry(0.3, 1.5, 6);
-                scale = 0.7;
-                break;
-                
-            case 'medium':
-            default:
-                // Medium/default: Standard cone shape
-                geometry = new THREE.ConeGeometry(0.5, 2, 6);
-                scale = 1.0;
-                break;
-        }
-        
-        const material = new THREE.MeshLambertMaterial({ 
-            color: color,
-            emissive: color,
-            emissiveIntensity: 0.1
-        });
-        
-        // Scale geometry if needed
-        if (scale !== 1.0) {
-            geometry.scale(scale, scale, scale);
-        }
-        
-        return { geometry, material };
-    }
-    
-    // Update aircraft visual indicators (direction, climb/descent)
-    update3DAircraftVisuals(mesh, aircraft) {
-        // Set aircraft direction based on track
-        if (aircraft.Track !== undefined && aircraft.Track !== 0) {
-            mesh.rotation.y = -aircraft.Track * Math.PI / 180;
-        }
-        
-        // Add climb/descent indicator
-        this.update3DClimbDescentIndicator(mesh, aircraft);
-    }
-    
-    // Add or update climb/descent visual indicator
-    update3DClimbDescentIndicator(mesh, aircraft) {
-        const verticalRate = aircraft.VerticalRate || 0;
-        const threshold = 500; // feet per minute
-        
-        // Remove existing indicator
-        const existingIndicator = mesh.getObjectByName('climbIndicator');
-        if (existingIndicator) {
-            mesh.remove(existingIndicator);
-        }
-        
-        // Add new indicator if significant vertical movement
-        if (Math.abs(verticalRate) > threshold) {
-            let indicatorGeometry, indicatorMaterial;
-            
-            if (verticalRate > threshold) {
-                // Climbing - green upward arrow
-                indicatorGeometry = new THREE.ConeGeometry(0.2, 0.8, 4);
-                indicatorMaterial = new THREE.MeshBasicMaterial({ 
-                    color: 0x00ff00, 
-                    transparent: true, 
-                    opacity: 0.8 
-                });
-            } else if (verticalRate < -threshold) {
-                // Descending - red downward arrow
-                indicatorGeometry = new THREE.ConeGeometry(0.2, 0.8, 4);
-                indicatorMaterial = new THREE.MeshBasicMaterial({ 
-                    color: 0xff0000, 
-                    transparent: true, 
-                    opacity: 0.8 
-                });
-                indicatorGeometry.rotateX(Math.PI); // Flip for downward arrow
-            }
-            
-            if (indicatorGeometry && indicatorMaterial) {
-                const indicator = new THREE.Mesh(indicatorGeometry, indicatorMaterial);
-                indicator.name = 'climbIndicator';
-                indicator.position.set(0, 2, 0); // Position above aircraft
-                mesh.add(indicator);
-            }
-        }
-    }
-    
-    // Apply signal quality visual effects to aircraft mesh
-    apply3DSignalQualityEffects(mesh, aircraft) {
-        // Get signal quality data from sources
-        const signalData = this.getAircraftSignalData(aircraft);
-        
-        // Apply opacity based on signal strength
-        this.updateAircraftOpacity(mesh, signalData);
-        
-        // Apply emissive intensity based on signal quality
-        this.updateAircraftEmissiveIntensity(mesh, signalData);
-        
-        // Add data source indicator
-        this.addDataSourceIndicator(mesh, signalData);
-    }
-    
-    // Extract signal data from aircraft sources
-    getAircraftSignalData(aircraft) {
-        if (!aircraft.sources || Object.keys(aircraft.sources).length === 0) {
-            return {
-                bestSignal: -50, // Default medium signal
-                sourceCount: 0,
-                primarySource: null,
-                signalQuality: 'Unknown'
-            };
-        }
-        
-        let bestSignal = -999;
-        let sourceCount = 0;
-        let primarySource = null;
-        
-        // Find strongest signal and count sources
-        Object.entries(aircraft.sources).forEach(([sourceId, sourceData]) => {
-            sourceCount++;
-            if (sourceData.signal_level > bestSignal) {
-                bestSignal = sourceData.signal_level;
-                primarySource = sourceId;
-            }
-        });
-        
-        return {
-            bestSignal,
-            sourceCount,
-            primarySource,
-            signalQuality: aircraft.SignalQuality || 'Unknown'
-        };
-    }
-    
-    // Update aircraft opacity based on signal strength
-    updateAircraftOpacity(mesh, signalData) {
-        // Map signal strength to opacity (stronger signal = more opaque)
-        // Typical ADS-B signal range: -60 dBFS (weak) to 0 dBFS (strong)
-        const minSignal = -60;
-        const maxSignal = -5;
-        const minOpacity = 0.3;
-        const maxOpacity = 1.0;
-        
-        // Clamp signal to expected range
-        const clampedSignal = Math.max(minSignal, Math.min(maxSignal, signalData.bestSignal));
-        
-        // Calculate opacity (linear mapping)
-        const signalRange = maxSignal - minSignal;
-        const signalNormalized = (clampedSignal - minSignal) / signalRange;
-        const opacity = minOpacity + (signalNormalized * (maxOpacity - minOpacity));
-        
-        // Apply opacity to material
-        mesh.material.transparent = true;
-        mesh.material.opacity = opacity;
-        
-        // Also adjust emissive intensity for glow effect
-        const baseEmissiveIntensity = 0.1;
-        const maxEmissiveBoost = 0.3;
-        mesh.material.emissiveIntensity = baseEmissiveIntensity + (signalNormalized * maxEmissiveBoost);
-    }
-    
-    // Update emissive intensity based on signal quality assessment
-    updateAircraftEmissiveIntensity(mesh, signalData) {
-        let qualityMultiplier = 1.0;
-        
-        // Adjust based on signal quality description
-        switch (signalData.signalQuality) {
-            case 'Excellent':
-                qualityMultiplier = 1.5;
-                break;
-            case 'Good':
-                qualityMultiplier = 1.2;
-                break;
-            case 'Fair':
-                qualityMultiplier = 0.8;
-                break;
-            case 'Poor':
-                qualityMultiplier = 0.5;
-                break;
-            default:
-                qualityMultiplier = 1.0;
-        }
-        
-        // Apply quality multiplier to emissive intensity
-        const currentIntensity = mesh.material.emissiveIntensity || 0.1;
-        mesh.material.emissiveIntensity = Math.min(0.5, currentIntensity * qualityMultiplier);
-    }
-    
-    // Add visual indicator for data source type
-    addDataSourceIndicator(mesh, signalData) {
-        // Remove existing source indicator
-        const existingIndicator = mesh.getObjectByName('sourceIndicator');
-        if (existingIndicator) {
-            mesh.remove(existingIndicator);
-        }
-        
-        // Only add indicator if we have multiple sources
-        if (signalData.sourceCount > 1) {
-            // Create small indicator showing multi-source data
-            const indicatorGeometry = new THREE.SphereGeometry(0.1, 4, 4);
-            const indicatorMaterial = new THREE.MeshBasicMaterial({ 
-                color: signalData.sourceCount > 2 ? 0x00ff00 : 0xffaa00, // Green for 3+, orange for 2
-                transparent: true, 
-                opacity: 0.7 
-            });
-            
-            const indicator = new THREE.Mesh(indicatorGeometry, indicatorMaterial);
-            indicator.name = 'sourceIndicator';
-            indicator.position.set(1, 1, 0); // Position to side of aircraft
-            mesh.add(indicator);
-        }
-    }
-    
-    // Create enhanced trail geometry with gradient colors and speed-based effects
-    create3DTrailGeometry(points, aircraft) {
-        const geometry = new THREE.BufferGeometry();
-        
-        // Set positions
-        const positions = new Float32Array(points.length * 3);
-        const colors = new Float32Array(points.length * 3);
-        
-        // Get signal quality for trail styling
-        const signalData = this.getAircraftSignalData(aircraft);
-        const baseTrailColor = this.getTrailColor(aircraft, signalData);
-        
-        // Calculate colors with gradient effect (newer = brighter, older = dimmer)
-        for (let i = 0; i < points.length; i++) {
-            // Position
-            positions[i * 3] = points[i].x;
-            positions[i * 3 + 1] = points[i].y;
-            positions[i * 3 + 2] = points[i].z;
-            
-            // Color with age-based fading
-            const ageRatio = i / (points.length - 1); // 0 = oldest, 1 = newest
-            const intensity = 0.3 + (ageRatio * 0.7); // Fade from 30% to 100% brightness
-            
-            colors[i * 3] = baseTrailColor.r * intensity;     // Red
-            colors[i * 3 + 1] = baseTrailColor.g * intensity; // Green  
-            colors[i * 3 + 2] = baseTrailColor.b * intensity; // Blue
-        }
-        
-        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
-        geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
-        
-        return geometry;
-    }
-    
-    // Get trail color based on aircraft type and signal quality
-    getTrailColor(aircraft, signalData) {
-        const visualType = this.getAircraftVisualType(aircraft);
-        
-        // Base colors for different aircraft types (more muted for trails)
-        let baseColor;
-        switch (visualType) {
-            case 'helicopter':
-                baseColor = { r: 0.0, g: 0.8, b: 0.8 }; // Cyan
-                break;
-            case 'heavy':
-                baseColor = { r: 0.0, g: 0.4, b: 0.8 }; // Blue
-                break;
-            case 'light':
-                baseColor = { r: 0.8, g: 0.8, b: 0.0 }; // Yellow
-                break;
-            case 'medium':
-            default:
-                baseColor = { r: 0.0, g: 0.6, b: 0.4 }; // Teal-green
-                break;
-        }
-        
-        // Adjust brightness based on signal quality
-        const qualityMultiplier = this.getSignalQualityMultiplier(signalData.signalQuality);
-        
-        return {
-            r: Math.min(1.0, baseColor.r * qualityMultiplier),
-            g: Math.min(1.0, baseColor.g * qualityMultiplier),
-            b: Math.min(1.0, baseColor.b * qualityMultiplier)
-        };
-    }
-    
-    // Get brightness multiplier based on signal quality
-    getSignalQualityMultiplier(signalQuality) {
-        switch (signalQuality) {
-            case 'Excellent': return 1.2;
-            case 'Good': return 1.0;
-            case 'Fair': return 0.8;
-            case 'Poor': return 0.6;
-            default: return 0.9;
-        }
     }
 
     initialize3DControls() {
@@ -1565,13 +684,6 @@ class SkyView {
             autoRotateButton.addEventListener('click', () => this.toggle3DAutoRotate());
         }
         
-        // Enable and initialize the Trails toggle button
-        const trailsButton = document.getElementById('radar3d-trails');
-        if (trailsButton) {
-            trailsButton.disabled = false;
-            trailsButton.addEventListener('click', () => this.toggle3DTrails());
-        }
-        
         // Enable and initialize the Range slider
         const rangeSlider = document.getElementById('radar3d-range');
         const rangeValue = document.getElementById('radar3d-range-value');
diff --git a/internal/merger/merger.go b/internal/merger/merger.go
index f2dfb07..0d907ce 100644
--- a/internal/merger/merger.go
+++ b/internal/merger/merger.go
@@ -227,11 +227,10 @@ type SourceData struct {
 // PositionPoint represents a timestamped position update in aircraft history.
 // Used to build position trails for visualization and track analysis.
 type PositionPoint struct {
-	Time      time.Time `json:"time"`     // Timestamp when position was received
-	Latitude  float64   `json:"lat"`      // Latitude in decimal degrees
-	Longitude float64   `json:"lon"`      // Longitude in decimal degrees
-	Altitude  int       `json:"altitude"` // Altitude in feet (0 if unknown)
-	Source    string    `json:"source"`   // Source that provided this position
+	Time      time.Time `json:"time"`   // Timestamp when position was received
+	Latitude  float64   `json:"lat"`    // Latitude in decimal degrees
+	Longitude float64   `json:"lon"`    // Longitude in decimal degrees
+	Source    string    `json:"source"` // Source that provided this position
 }
 
 // SignalPoint represents a timestamped signal strength measurement.
@@ -656,7 +655,6 @@ func (m *Merger) updateHistories(state *AircraftState, aircraft *modes.Aircraft,
 				Time:      timestamp,
 				Latitude:  aircraft.Latitude,
 				Longitude: aircraft.Longitude,
-				Altitude:  aircraft.Altitude, // Include altitude in position history
 				Source:    sourceID,
 			})
 		}