v2.2.0: Fix floating window sizing and state synchronization

- Fix overlay size calculation to use physical pixels instead of scaled logical pixels
- Add proper state synchronization between main app and overlay for close events
- Improve overlay close button functionality with bidirectional communication
- Add comprehensive debug output for screen size analysis
- Update overlay visual tweaks (close button sizing, speed display improvements)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/settings.local.json

@@ -13,7 +13,10 @@
       "Bash(cp:*)",
       "Bash(flutter:*)",
       "Bash(powershell:*)",
-      "WebFetch(domain:docs.anthropic.com)"
+      "WebFetch(domain:docs.anthropic.com)",
+      "WebSearch",
+      "WebFetch(domain:pub.dev)",
+      "Bash(git commit:*)"
     ],
     "defaultMode": "acceptEdits"
   },

CLAUDE.md

@@ -3,8 +3,8 @@
 ## Project Overview
 A customizable Flutter GPS speedometer app targeting Android devices, emphasizing modularity and user customization.
 
-## Current Status: v1.1 Complete 
-**Enhanced GPS speedometer with improved user experience and customization options.**
+## Current Status: v2.1.0 Complete 
+**GPS speedometer with floating window overlay functionality and optimized visual design.**
 
 ### Architecture Implemented
 - **State Management:** Provider pattern
@@ -25,25 +25,50 @@ A customizable Flutter GPS speedometer app targeting Android devices, emphasizin
 
 ### Technical Stack
 ```
-Dependencies: geolocator, permission_handler, provider, shared_preferences, flutter_material_color_picker
+Dependencies: geolocator, permission_handler, provider, shared_preferences, flutter_material_color_picker, flutter_overlay_window
 Platforms: Android (primary), iOS support included but untested
 Architecture: Provider + Consumer pattern for reactive state management
-Permissions: Location services with graceful degradation
+Permissions: Location services + SYSTEM_ALERT_WINDOW for overlay functionality
 ```
 
-## Recent Updates (v1.1)
+## Recent Updates (v2.1.0)
 
-### ✅ Completed Features
+### ✅ Completed Features (Master Branch - Stable)
+- [x] **Split Decimal Display**: Main speed prominent with smaller, faded decimal fraction for better readability
+- [x] **Optimized Content Sizing**: Maximized readability with improved responsive layout and flex ratios
+- [x] **Basic Floating Window**: Simple overlay with "GPS SPEEDO" text and close button (stable implementation)
+- [x] **Navigation Icon Trigger**: Tap compass/navigation area to launch floating window overlay
+- [x] **Multiple Close Options**: Overlay close button and long-press navigation area for easy dismissal
+- [x] **Android System Integration**: SYSTEM_ALERT_WINDOW permissions and foreground service configuration
+
+### 🚧 Work in Progress Features (dev/floating-window-wip Branch - Seriously Buggy)
+- [ ] **Advanced Floating Window Overlay**: System-level overlay with live GPS data - basic functionality works but seriously buggy
+  - GPS data synchronization implemented but unreliable
+  - Theme/unit sync between main app and overlay works partially
+  - Proportional sizing and positioning needs major refinement
+  - Close button functionality works but overlay behavior inconsistent
+  - Performance may impact main app, needs optimization
+
+### Previous Updates (v1.1)
 - [x] **Portrait/Landscape Support**: Automatic orientation detection implemented  
 - [x] **Interactive Gauge**: Click gauge face to switch digital/analog modes
 - [x] **Extended Speed Units**: Added knots support with quick selector buttons
 
 ## TODO - Future Improvements
 
-### Critical Issues
-- [ ] **Dependency Updates**: Update 10 packages to latest compatible versions
+### Known Issues
+
+**Master Branch (v2.1.0 - Stable):**
+- [ ] **Dependency Updates**: Update packages to latest compatible versions
 - [ ] **Orientation Override**: Fix auto-rotate to work regardless of system toggle status
 
+**Dev Branch (floating-window-wip - Seriously Buggy):**
+- [ ] **Floating Window Reliability**: Overlay behavior inconsistent across different devices and Android versions
+- [ ] **GPS Data Sync**: Real-time GPS synchronization between main app and overlay unreliable
+- [ ] **Theme/Unit Sync**: Setting synchronization works partially but not consistently
+- [ ] **Overlay Positioning**: Poor positioning stability, sizing calculations need major work
+- [ ] **Performance**: Overlay may impact main app performance, needs optimization
+
 ### UI/UX Enhancements
 - [ ] **Background Customization**: Custom background color selection
 - [ ] **Interface Rearrangement**: User-defined layout customization
@@ -66,6 +91,11 @@ Permissions: Location services with graceful degradation
 - **Memory**: Project uses automatic Claude Code memory - this file for major decisions only
 - **Git**: Active repository at `https://github.com/mikkelimatlock/gps_speedo`
 
+## Branch Strategy
+- **master**: Stable releases, ready for production APK builds
+- **dev/floating-window-wip**: Advanced floating window development (seriously buggy, not for release)
+- Tagged releases: v2.1.0 on master branch contains stable basic floating window
+
 ## Code Patterns to Maintain
 - Provider pattern for state management
 - Separate widgets for reusability  

android/app/src/main/AndroidManifest.xml

@@ -5,8 +5,10 @@
     <!-- Optional: for background location access -->
     <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
     
-    <!-- TODO: Enable for display-over-apps functionality -->
-    <!-- <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" /> -->
+    <!-- Overlay window permissions for floating speedometer -->
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
     
     <application
         android:label="Speedo"
@@ -34,6 +36,12 @@
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
         </activity>
+        
+        <!-- Service for overlay window -->
+        <service
+            android:name="flutter.overlay.window.flutter_overlay_window.OverlayService"
+            android:exported="false" />
+        
         <!-- Don't delete the meta-data below.
              This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
         <meta-data

lib/color_themes.dart

@@ -3,6 +3,7 @@ import 'package:flutter/material.dart';
 class ColorTheme {
   final Color background;
   final Color speedText;
+  final Color speedTextSub;
   final Color headingText;
   final Color unitText;
   final String name;
@@ -10,6 +11,7 @@ class ColorTheme {
   const ColorTheme({
     required this.background,
     required this.speedText,
+    required this.speedTextSub,
     required this.headingText,
     required this.unitText,
     required this.name,
@@ -22,6 +24,7 @@ class ColorThemes {
       name: 'Yuzuki',
       background: Color.fromARGB(255, 114, 85, 109),
       speedText: Color.fromARGB(255, 246, 224, 255),
+      speedTextSub: Color.fromARGB(255, 245, 217, 245),
       headingText: Color.fromARGB(255, 244, 201, 255),
       unitText: Color.fromARGB(255, 244, 201, 255),
     ),
@@ -29,6 +32,7 @@ class ColorThemes {
       name: 'Yuuparo',
       background: Color.fromARGB(255, 85, 99, 112),
       speedText: Color.fromARGB(255, 255, 171, 16),
+      speedTextSub: Color.fromARGB(255, 245, 204, 116),
       headingText: Color.fromARGB(255, 228, 235, 238),
       unitText: Color.fromARGB(255, 141, 196, 184),
     ),
@@ -36,6 +40,7 @@ class ColorThemes {
       name: 'Yuzuki Light',
       background: Color.fromARGB(255, 246, 224, 255),
       speedText: Color.fromARGB(255, 114, 85, 109),
+      speedTextSub: Color.fromARGB(255, 161, 138, 170),
       headingText: Color.fromARGB(255, 140, 94, 151),
       unitText: Color.fromARGB(255, 114, 85, 109),
     ),
@@ -43,6 +48,7 @@ class ColorThemes {
       name: 'Yuuparo Light',
       background: Color.fromARGB(255, 228, 235, 238),
       speedText: Color.fromARGB(255, 85, 99, 112),
+      speedTextSub: Color.fromARGB(255, 100, 100, 131),
       headingText: Color.fromARGB(255, 255, 157, 65),
       unitText: Color.fromARGB(255, 98, 124, 118),
     ),

lib/gps_service.dart

@@ -41,6 +41,6 @@ class GpsService {
   
   static String formatHeading(double heading) {
     final cachedHeading = getCachedHeading(heading);
-    return '${cachedHeading.round()}° ${getCompassDirection(heading)}';
+    return '${cachedHeading.round()} ${getCompassDirection(heading)}'; // don't add that degree symbol, this is cooler
   }
 }

lib/main.dart

@@ -1,20 +1,33 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/foundation.dart'; // For kDebugMode
 import 'dart:async';
 import 'package:geolocator/geolocator.dart';
 import 'package:wakelock_plus/wakelock_plus.dart';
+import 'package:flutter_overlay_window/flutter_overlay_window.dart';
 import 'speed_units.dart';
 import 'gps_service.dart';
 import 'color_themes.dart';
 import 'dart:math' as math; // Import for math.pi
 
+// Debug helper - only prints in debug builds
+void customDebugPrint(String message) {
+  if (kDebugMode) {
+    print(message);
+  }
+}
+
 void main() {
   runApp(const SpeedoApp());
 }
 
-// Entry point for future overlay mode
-void mainOverlay() {
-  // TODO: Initialize overlay-specific setup
-  runApp(const SpeedoApp(isOverlayMode: true));
+// Entry point for overlay window
+@pragma("vm:entry-point")
+void overlayMain() {
+  customDebugPrint('[Overlay] 🚀 overlayMain() called');
+  runApp(const MaterialApp(
+    debugShowCheckedModeBanner: false,
+    home: OverlaySpeedometer(),
+  ));
 }
 
 class SpeedoApp extends StatelessWidget {
@@ -46,19 +59,55 @@ class SpeedometerScreen extends StatefulWidget {
   State<SpeedometerScreen> createState() => _SpeedometerScreenState();
 }
 
-class _SpeedometerScreenState extends State<SpeedometerScreen> {
+class _SpeedometerScreenState extends State<SpeedometerScreen> with WidgetsBindingObserver {
   double _speed = 0.0;
   double _heading = -1.0;
   SpeedUnit _currentUnit = SpeedUnit.kmh;
   int _currentThemeIndex = 0;
   StreamSubscription<Position>? _positionSubscription;
   String _errorMessage = '';
+  bool _isInBackground = false;
+  bool _isOverlayActive = false;
+  
+  // Single source of truth for overlay sizing
+  Map<String, int> _getOverlaySize() {
+    final window = WidgetsBinding.instance.platformDispatcher.views.first;
+    final physicalSize = window.physicalSize;
+    final devicePixelRatio = window.devicePixelRatio;
+    final systemSize = physicalSize / devicePixelRatio;
+    
+    customDebugPrint('[Main] 🔍 Screen size analysis:');
+    customDebugPrint('  physicalSize: ${physicalSize.width.round()}x${physicalSize.height.round()}');
+    customDebugPrint('  devicePixelRatio: $devicePixelRatio');
+    customDebugPrint('  calculated systemSize: ${systemSize.width.round()}x${systemSize.height.round()}');
+    
+    // Use actual physical pixels, not scaled logical pixels
+    final overlayWidth = (physicalSize.width * 0.4).round(); // 40% of actual screen width
+    final overlayHeight = (overlayWidth * 0.6).round();
+    
+    customDebugPrint('  using fixed overlay size: ${overlayWidth}x${overlayHeight}');
+    
+    return {'width': overlayWidth, 'height': overlayHeight};
+  }
 
   @override
   void initState() {
     super.initState();
+    WidgetsBinding.instance.addObserver(this);
     _initializeGps();
     _enableWakelock();
+    _listenToOverlayMessages();
+  }
+  
+  void _listenToOverlayMessages() {
+    FlutterOverlayWindow.overlayListener.listen((data) {
+      if (data is Map && data['action'] == 'overlayClosed') {
+        customDebugPrint('[Main] 📡 Received overlay close notification');
+        setState(() {
+          _isOverlayActive = false;
+        });
+      }
+    });
   }
 
   Future<void> _enableWakelock() async {
@@ -71,11 +120,43 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
 
   @override
   void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
     _positionSubscription?.cancel();
     WakelockPlus.disable();
     super.dispose();
   }
 
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    super.didChangeAppLifecycleState(state);
+    
+    switch (state) {
+      case AppLifecycleState.paused:
+        // App went to background (home key pressed or task switch)
+        if (!_isInBackground) {
+          _isInBackground = true;
+          _handleBackgroundTransition();
+        }
+        break;
+      case AppLifecycleState.resumed:
+        // App came back to foreground
+        _isInBackground = false;
+        break;
+      case AppLifecycleState.inactive:
+      case AppLifecycleState.detached:
+      case AppLifecycleState.hidden:
+        break;
+    }
+  }
+
+  void _handleBackgroundTransition() {
+    // When app goes to background, show floating window if GPS is active and no error
+    // Temporarily disable auto-trigger for debugging
+    // if (_speed >= 0 && _errorMessage.isEmpty) {
+    //   _showFloatingWindow();
+    // }
+  }
+
   Future<void> _initializeGps() async {
     try {
       final serviceEnabled = await GpsService.isLocationServiceEnabled();
@@ -111,18 +192,107 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
       _heading = position.heading;
       _errorMessage = '';
     });
+    
+    // Push display data to overlay if active
+    _pushDataToOverlay();
+  }
+  
+  void _pushDataToOverlay() {
+    // Send complete display data to overlay including screen size
+    final displaySpeed = _currentUnit.convert(_speed);
+    final speedText = displaySpeed < 1.0 ? '--' : displaySpeed.toInt().toString();
+    final headingText = GpsService.formatHeading(_heading);
+    
+    customDebugPrint('[Main] 📤 SENDING to overlay:');
+    customDebugPrint('  speedText: "$speedText"');
+    customDebugPrint('  headingText: "$headingText"');
+    customDebugPrint('  direction: ${_heading.toStringAsFixed(1)}°');
+    customDebugPrint('  unit: ${_currentUnit.label}, theme: $_currentThemeIndex');
+    
+    FlutterOverlayWindow.shareData({
+      'action': 'updateDisplay',
+      'speedText': speedText,
+      'headingText': headingText,
+      'heading': _heading,
+      'unitIndex': _currentUnit.index,
+      'themeIndex': _currentThemeIndex,
+    });
   }
 
   void _cycleUnit() {
     setState(() {
       _currentUnit = _currentUnit.next;
     });
+    // Push updated display data to overlay
+    _pushDataToOverlay();
   }
 
   void _cycleTheme() {
     setState(() {
       _currentThemeIndex = ColorThemes.getNextThemeIndex(_currentThemeIndex);
     });
+    // Push updated display data to overlay
+    _pushDataToOverlay();
+  }
+
+  Future<void> _showFloatingWindow() async {
+    try {
+      // Use centralized sizing function
+      final overlaySize = _getOverlaySize();
+      
+      // Send initial display data WITH size info (only needed on creation)
+      final displaySpeed = _currentUnit.convert(_speed);
+      final speedText = displaySpeed < 1.0 ? '--' : displaySpeed.toInt().toString();
+      final headingText = GpsService.formatHeading(_heading);
+      
+      await FlutterOverlayWindow.shareData({
+        'action': 'updateDisplay',
+        'speedText': speedText,
+        'headingText': headingText,
+        'heading': _heading,
+        'unitIndex': _currentUnit.index,
+        'themeIndex': _currentThemeIndex,
+        'overlayWidth': overlaySize['width']!.toDouble(),
+        'overlayHeight': overlaySize['height']!.toDouble(),
+      });
+
+      // Show the overlay with proportional sizing based on system resolution
+      await FlutterOverlayWindow.showOverlay(
+        enableDrag: true,
+        overlayTitle: "GPS Speedometer",
+        overlayContent: 'GPS Speedometer Overlay',
+        flag: OverlayFlag.defaultFlag,
+        visibility: NotificationVisibility.visibilityPublic,
+        positionGravity: PositionGravity.none,
+        // Use consistent sizing from centralized function
+        width: overlaySize['width']!,
+        height: overlaySize['height']!,
+      );
+      
+      customDebugPrint('[Main] 🟢 OVERLAY LAUNCHED - Size: ${overlaySize['width']}x${overlaySize['height']}');
+      setState(() {
+        _isOverlayActive = true;
+      });
+    } catch (e) {
+      // Silent error handling - floating window issues shouldn't crash main app
+    }
+  }
+
+  Future<void> _closeFloatingWindow() async {
+    if (!_isOverlayActive) {
+      customDebugPrint('[Main] ⚠️  No overlay to close');
+      return;
+    }
+    
+    try {
+      await FlutterOverlayWindow.closeOverlay();
+      customDebugPrint('[Main] 🔴 OVERLAY CLOSED - Requested from main app');
+      setState(() {
+        _isOverlayActive = false;
+      });
+    } catch (e) {
+      customDebugPrint('[Main] ❌ Error closing overlay: $e');
+    }
   }
   
   String _getSpeedDisplayText(double displaySpeed) {
@@ -132,6 +302,51 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
     return displaySpeed.toStringAsFixed(1);
   }
 
+  Widget _buildSpeedDisplay(String speedText, ColorTheme currentTheme, double fontSize, {bool isLandscape = false}) {
+    if (speedText == '--') {
+      return Text(
+        speedText,
+        style: TextStyle(
+          fontSize: fontSize,
+          fontWeight: FontWeight.w300,
+          color: currentTheme.speedText,
+          fontFamily: 'DIN1451Alt',
+        ),
+      );
+    }
+
+    // Split speed into integral and decimal parts
+    final parts = speedText.split('.');
+    final integralPart = parts[0];
+    final decimalPart = parts.length > 1 ? '.${parts[1]}' : '.0';
+
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.center,
+      crossAxisAlignment: CrossAxisAlignment.baseline,
+      textBaseline: TextBaseline.alphabetic,
+      children: [
+        Text(
+          integralPart,
+          style: TextStyle(
+            fontSize: fontSize,
+            fontWeight: FontWeight.w300,
+            color: currentTheme.speedText,
+            fontFamily: 'DIN1451Alt',
+          ),
+        ),
+        Text(
+          decimalPart,
+          style: TextStyle(
+            fontSize: fontSize * 0.5, // 60% of main font size
+            fontWeight: FontWeight.w300,
+            color: currentTheme.speedTextSub,
+            fontFamily: 'DIN1451Alt',
+          ),
+        ),
+      ],
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final displaySpeed = _currentUnit.convert(_speed);
@@ -161,11 +376,11 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
       children: [
         // Speed area - takes most space, precise tap targets on text only
         Expanded(
-          flex: 7,
+          flex: 65,
           child: Container(
             width: double.infinity,
             color: Colors.transparent,
-            padding: const EdgeInsets.all(12),
+            padding: const EdgeInsets.all(4),
             child: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: [
@@ -183,33 +398,25 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
                   )
                 else ...[
                   Flexible(
-                    flex: 3,
+                    flex: 4,
                     child: GestureDetector(
-                      onTap: _cycleUnit,
+                      onTap: _cycleTheme, // Tap speed to cycle theme
                       child: FittedBox(
-                        fit: BoxFit.scaleDown,
-                        child: Text(
-                          speedText,
-                          style: TextStyle(
-                            fontSize: 160,
-                            fontWeight: FontWeight.w300,
-                            color: currentTheme.speedText,
-                            fontFamily: 'DIN1451Alt',
-                          ),
-                        ),
+                        fit: BoxFit.contain,
+                        child: _buildSpeedDisplay(speedText, currentTheme, 200),
                       ),
                     ),
                   ),
                   Flexible(
                     flex: 1,
                     child: GestureDetector(
-                      onTap: _cycleUnit,
+                      onTap: _cycleUnit, // clicking on unit to cycle unit is more intuitive
                       child: FittedBox(
-                        fit: BoxFit.scaleDown,
+                        fit: BoxFit.contain,
                         child: Text(
                           _currentUnit.label,
                           style: TextStyle(
-                            fontSize: 64,
+                            fontSize: 80,
                             color: currentTheme.unitText,
                             fontFamily: 'DIN1451Alt',
                           ),
@@ -222,37 +429,51 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
             ),
           ),
         ),
-        // Compass area - compact but fully tappable for theme cycling
+        // Compass area - compact but fully tappable for floating window
         Expanded(
-          flex: 3,
+          flex: 32,
           child: GestureDetector(
-            onTap: _cycleTheme,
+            onTap: () {
+              customDebugPrint('[Main] 🖱️  Navigation area tapped - overlay active: $_isOverlayActive');
+              if (_isOverlayActive) {
+                _closeFloatingWindow();
+              } else {
+                _showFloatingWindow();
+              }
+            },
+            onLongPress: () {
+              customDebugPrint('[Main] 🖱️  Navigation area long-pressed - overlay active: $_isOverlayActive');
+              _closeFloatingWindow();
+            },
             child: Container(
               width: double.infinity,
               color: Colors.transparent,
-              padding: const EdgeInsets.all(16),
+              padding: const EdgeInsets.all(2),
               child: Column(
                 mainAxisAlignment: MainAxisAlignment.center,
                 children: [
                   Flexible(
-                    flex: 2,
+                    flex: 3,
                     child: Transform.rotate(
                       angle: (_heading >= 0 && _heading < 360) ? (_heading * math.pi / 180.0) : 0,
+                      child: FittedBox(
+                        fit: BoxFit.contain,
                         child: Icon(
                           Icons.navigation,
-                        size: 100,
+                          size: 80,
                           color: currentTheme.headingText,
                         ),
                       ),
                     ),
+                  ),
                   Flexible(
                     flex: 1,
                     child: FittedBox(
-                      fit: BoxFit.scaleDown,
+                      fit: BoxFit.contain,
                       child: Text(
                         GpsService.formatHeading(_heading),
                         style: TextStyle(
-                          fontSize: 96,
+                          fontSize: 50,
                           color: currentTheme.headingText,
                           fontFamily: 'DIN1451Alt',
                         ),
@@ -273,11 +494,11 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
       children: [
         // Speed area - takes majority of space, precise tap targets on text only
         Expanded(
-          flex: 65,
+          flex: 66,
           child: Container(
             height: double.infinity,
             color: Colors.transparent,
-            padding: const EdgeInsets.all(16),
+            padding: const EdgeInsets.all(3),
             child: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: [
@@ -295,33 +516,29 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
                   )
                 else ...[
                   Flexible(
-                    flex: 3,
+                    flex: 1,
+                    child: FittedBox(),
+                  ),
+                  Flexible(
+                    flex: 20,
                     child: GestureDetector(
-                      onTap: _cycleUnit,
+                      onTap: _cycleTheme,
                       child: FittedBox(
-                        fit: BoxFit.scaleDown,
-                        child: Text(
-                          speedText,
-                          style: TextStyle(
-                            fontSize: 120,
-                            fontWeight: FontWeight.w300,
-                            color: currentTheme.speedText,
-                            fontFamily: 'DIN1451Alt',
-                          ),
-                        ),
+                        fit: BoxFit.contain,
+                        child: _buildSpeedDisplay(speedText, currentTheme, 160, isLandscape: true),
                       ),
                     ),
                   ),
                   Flexible(
-                    flex: 1,
+                    flex: 7,
                     child: GestureDetector(
                       onTap: _cycleUnit,
                       child: FittedBox(
-                        fit: BoxFit.scaleDown,
+                        fit: BoxFit.contain,
                         child: Text(
                           _currentUnit.label,
                           style: TextStyle(
-                            fontSize: 24,
+                            fontSize: 50,
                             color: currentTheme.unitText,
                             fontFamily: 'DIN1451Alt',
                           ),
@@ -329,40 +546,60 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
                       ),
                     ),
                   ),
+                  Flexible(
+                    flex: 5,
+                    child: FittedBox(),
+                  ),
                 ],
               ],
             ),
           ),
         ),
-        // Compass area - smaller but fully tappable for theme cycling
+        // Compass area - smaller but fully tappable for floating window
         Expanded(
-          flex: 35,
+          flex: 33,
           child: GestureDetector(
-            onTap: _cycleTheme,
+            onTap: () {
+              customDebugPrint('[Main] 🖱️  Navigation area tapped (landscape) - overlay active: $_isOverlayActive');
+              if (_isOverlayActive) {
+                _closeFloatingWindow();
+              } else {
+                _showFloatingWindow();
+              }
+            },
+            onLongPress: () {
+              customDebugPrint('[Main] 🖱️  Navigation area long-pressed (landscape) - overlay active: $_isOverlayActive');
+              _closeFloatingWindow();
+            },
             child: Container(
               height: double.infinity,
               color: Colors.transparent,
-              padding: const EdgeInsets.all(16),
+              padding: const EdgeInsets.all(2),
               child: Column(
                 mainAxisAlignment: MainAxisAlignment.center,
                 children: [
                   Flexible(
-                    flex: 2,
+                    flex: 3,
+                    child: Transform.rotate(
+                      angle: (_heading >= 0 && _heading < 360) ? (_heading * math.pi / 180.0) : 0,
+                      child: FittedBox(
+                        fit: BoxFit.contain,
                         child: Icon(
                           Icons.navigation,
-                      size: 32,
+                          size: 60,
                           color: currentTheme.headingText,
                         ),
                       ),
-                  const SizedBox(height: 8),
+                    ),
+                  ),
                   Flexible(
                     flex: 1,
                     child: FittedBox(
-                      fit: BoxFit.scaleDown,
+                      fit: BoxFit.contain,
                       child: Text(
                         GpsService.formatHeading(_heading),
                         style: TextStyle(
-                          fontSize: 18,
+                          fontSize: 30,
                           color: currentTheme.headingText,
                           fontFamily: 'DIN1451Alt',
                         ),
@@ -378,3 +615,224 @@ class _SpeedometerScreenState extends State<SpeedometerScreen> {
     );
   }
 }
+
+class OverlaySpeedometer extends StatefulWidget {
+  const OverlaySpeedometer({super.key});
+
+  @override
+  State<OverlaySpeedometer> createState() => _OverlaySpeedometerState();
+}
+
+class _OverlaySpeedometerState extends State<OverlaySpeedometer> {
+  String _speedText = '--';
+  String _headingText = 'N/A';
+  double _heading = -1.0;
+  int _currentThemeIndex = 0;
+  double _systemScreenWidth = 400;
+  double _overlayWidth = 280;
+  double _overlayHeight = 140;
+
+  @override
+  void initState() {
+    super.initState();
+    customDebugPrint('[Overlay] 🟢 CREATED - Floating window initialized');
+    _getSystemScreenSize();
+    _listenToMainAppMessages();
+  }
+
+  void _getSystemScreenSize() {
+    try {
+      // Get actual system screen resolution, not just app window size
+      final window = WidgetsBinding.instance.platformDispatcher.views.first;
+      final physicalSize = window.physicalSize;
+      final devicePixelRatio = window.devicePixelRatio;
+      final systemSize = physicalSize / devicePixelRatio;
+      
+      customDebugPrint('[Overlay] 🔍 Screen detection:');
+      customDebugPrint('  physicalSize: ${physicalSize.width.round()}x${physicalSize.height.round()}');
+      customDebugPrint('  devicePixelRatio: $devicePixelRatio');
+      customDebugPrint('  calculated systemSize: ${systemSize.width.round()}x${systemSize.height.round()}');
+      
+      setState(() {
+        _systemScreenWidth = systemSize.width;
+      });
+      
+      customDebugPrint('[Overlay] ✅ _systemScreenWidth set to: ${_systemScreenWidth.round()}');
+    } catch (e) {
+      customDebugPrint('[Overlay] ❌ Error getting system screen size: $e');
+      // Fallback to reasonable default
+      setState(() {
+        _systemScreenWidth = 400;
+      });
+    }
+  }
+
+  void _listenToMainAppMessages() {
+    FlutterOverlayWindow.overlayListener.listen((data) {
+      if (data is Map && data['action'] == 'updateDisplay') {
+        setState(() {
+          _speedText = data['speedText'] ?? '--';
+          _headingText = data['headingText'] ?? 'N/A';
+          _heading = data['heading']?.toDouble() ?? -1.0;
+          _currentThemeIndex = data['themeIndex'] ?? 0;
+          // Update screen size and overlay dimensions if provided by main app
+          if (data.containsKey('systemScreenWidth')) {
+            _systemScreenWidth = data['systemScreenWidth']?.toDouble() ?? _systemScreenWidth;
+          }
+          if (data.containsKey('overlayWidth')) {
+            _overlayWidth = data['overlayWidth']?.toDouble() ?? _overlayWidth;
+          }
+          if (data.containsKey('overlayHeight')) {
+            _overlayHeight = data['overlayHeight']?.toDouble() ?? _overlayHeight;
+          }
+        });
+        
+        customDebugPrint('[Overlay] 📡 UPDATE received:');
+        customDebugPrint('  speedText: "$_speedText"');
+        customDebugPrint('  headingText: "$_headingText"'); 
+        customDebugPrint('  direction: ${_heading.toStringAsFixed(1)}°');
+        customDebugPrint('  themeIndex: $_currentThemeIndex');
+        customDebugPrint('  systemScreenWidth: ${_systemScreenWidth.round()}');
+        customDebugPrint('  overlaySize from main: ${_overlayWidth.round()}x${_overlayHeight.round()}');
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    customDebugPrint('[Overlay] 🔴 DESTROYED - Floating window disposed');
+    // No GPS subscription to cancel - overlay is display-only
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final currentTheme = ColorThemes.getTheme(_currentThemeIndex);
+    
+    // Use overlay dimensions provided by main app (not calculated locally)
+    final fontSize = (_overlayWidth * 0.2); // Font size proportional to actual overlay width
+    
+    customDebugPrint('[Overlay] 📐 Window size: ${_overlayWidth.round()}x${_overlayHeight.round()}, fontSize: ${fontSize.round()}');
+
+    return Material(
+      color: Colors.transparent,
+      child: SizedBox(
+        // Use SizedBox to fill the overlay window completely
+        width: double.infinity,
+        height: double.infinity,
+        child: Container(
+          decoration: BoxDecoration(
+            color: currentTheme.background.withOpacity(0.85),
+            borderRadius: BorderRadius.circular(12),
+            border: Border.all(
+              color: currentTheme.speedText.withOpacity(0.3), 
+              width: 1
+            ),
+          ),
+          child: Stack(
+            children: [
+              // Main content - landscape layout (1:1 flex as per NOTES.txt)
+              Row(
+                children: [
+                  // Speed section - left half
+                  Expanded(
+                    flex: 1,
+                    child: Container(
+                      padding: const EdgeInsets.all(8),
+                      child: Center(
+                        child: FittedBox(
+                          fit: BoxFit.contain,
+                          child: Text(
+                            (_speedText == "--" ? "0" : _speedText),
+                            style: TextStyle(
+                              fontSize: fontSize,
+                              fontWeight: FontWeight.w300,
+                              color: currentTheme.speedText,
+                              fontFamily: 'DIN1451Alt',
+                            ),
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                  // Direction section - right half (same as full-screen behavior)
+                  Expanded(
+                    flex: 1,
+                    child: Container(
+                      padding: const EdgeInsets.all(8),
+                      child: Column(
+                        mainAxisAlignment: MainAxisAlignment.center,
+                        children: [
+                          Flexible(
+                            flex: 2,
+                            child: Transform.rotate(
+                              angle: (_heading >= 0 && _heading < 360) ? (_heading * math.pi / 180.0) : 0,
+                              child: FittedBox(
+                                fit: BoxFit.contain,
+                                child: Icon(
+                                  Icons.navigation,
+                                  size: fontSize * 0.8,
+                                  color: currentTheme.headingText,
+                                ),
+                              ),
+                            ),
+                          ),
+                          Flexible(
+                            flex: 1,
+                            child: FittedBox(
+                              fit: BoxFit.contain,
+                              child: Text(
+                                _headingText,
+                                style: TextStyle(
+                                  fontSize: fontSize * 0.4,
+                                  color: currentTheme.headingText,
+                                  fontFamily: 'DIN1451Alt',
+                                ),
+                              ),
+                            ),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+              // Semi-transparent close button (only interaction as per NOTES.txt)
+              Positioned(
+                top: 4,
+                right: 4,
+                child: GestureDetector(
+                  onTap: () {
+                    customDebugPrint('[Overlay] 🔴 Close button tapped');
+                    // Notify main app that overlay is closing
+                    FlutterOverlayWindow.shareData({
+                      'action': 'overlayClosed',
+                    });
+                    FlutterOverlayWindow.closeOverlay();
+                  },
+                  child: Container(
+                    width: 18,
+                    height: 18, // fixed
+                    decoration: BoxDecoration(
+                      color: Colors.transparent,
+                      borderRadius: BorderRadius.circular(_overlayHeight * 0.1),
+                      border: Border.all(
+                        color: currentTheme.speedTextSub.withOpacity(0.9),
+                        width: 1
+                      ),
+                    ),
+                    child: Icon(
+                      Icons.close,
+                      color: currentTheme.speedText.withOpacity(0.9),
+                      size: 15,
+                    ),
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

pubspec.lock

@@ -134,6 +134,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "6.0.0"
+  flutter_overlay_window:
+    dependency: "direct main"
+    description:
+      name: flutter_overlay_window
+      sha256: "17988420249da68e421d1b44b511e6113d3de7a9e52c3fbd6d99730508af4580"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.5.0"
   flutter_test:
     dependency: "direct dev"
     description: flutter

pubspec.yaml

@@ -2,7 +2,7 @@ name: gps_speedo
 description: "Speedo - A Flutter application."
 publish_to: 'none'
 
-version: 2.0.0+1
+version: 2.2.0+1
 
 environment:
   sdk: ^3.9.0
@@ -21,6 +21,9 @@ dependencies:
   # Keep screen awake during navigation
   wakelock_plus: ^1.2.8
   
+  # Floating window overlay capability
+  flutter_overlay_window: ^0.5.0
+
 
 dev_dependencies:
   flutter_test: