diff --git a/README.md b/README.md
index 7ddb10d2..1ad4d291 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,23 @@
-# OpenWearable - App
+# OpenWearables - App
 
-The OpenWearable App is a mobile application for connecting to, configuring, and interacting with wearable devices. It is designed as a flexible companion app for research, development, and prototyping with sensor-rich wearable platforms.
+The OpenWearables App is a mobile application for connecting to, configuring, and interacting with wearable devices. It is designed as a flexible companion app for research, development, and prototyping with sensor-rich wearable platforms.
 
-The app supports live sensor control, data visualizations and example applications that demonstrate how wearable devices can be used in practice. [OpenEarable](https://openearable.com) is one example of a compatible OpenWearable device. It is a fully open-source platform for ear-based sensing applications with true wireless audio, high-precision sensors, and a modular, reconfigurable hardware design.
+The app supports live sensor control, data visualizations and example applications that demonstrate how wearable devices can be used in practice. [OpenEarable](https://openearable.com) is one example of a compatible OpenWearables device. It is a fully open-source platform for ear-based sensing applications with true wireless audio, high-precision sensors, and a modular, reconfigurable hardware design.
 
-For more information about the OpenWearable ecosystem, visit [openwearables.com](https://openwearables.com).
+For more information about the OpenWearables ecosystem, visit [openwearables.com](https://openwearables.com).
+
+## Project Structure
+
+This repository is primarily the Flutter app in [`open_wearable/`](./open_wearable/).
+
+High-level architecture and state-management docs live in [`open_wearable/docs/`](./open_wearable/docs/README.md).
+
+- [App Setup and Architecture](./open_wearable/docs/app-setup.md)
+- [State and Providers](./open_wearable/docs/state-and-providers.md)
 
 ## Features
 
-- Connect to compatible OpenWearable devices, such as OpenEarable
+- Connect to compatible devices from OpenWearables, such as OpenEarable
 - Configure available device sensors
 - Control audio features
 - Show live data from wearable sensors
@@ -18,11 +27,37 @@ For more information about the OpenWearable ecosystem, visit [openwearables.com]
 
 ## Getting Started
 
-To get started with the OpenWearable App, you need:
+To get started with the OpenWearables App, you need:
 
-- A compatible OpenWearable device, such as an OpenEarable device with the latest firmware
+- A compatible OpenWearables device, such as an OpenEarable device with the latest firmware
 - A working Flutter installation
 
+## Development Quick Start
+
+1. Install Flutter on the stable channel.
+2. From the app module, fetch dependencies:
+
+    ```bash
+    cd open_wearable
+    flutter pub get
+    ```
+
+3. Run on a connected device or emulator:
+
+    ```bash
+    cd open_wearable
+    flutter run
+    ```
+
+To enter demo mode with simulated sensor values, start the app with the App Store preview flag:
+
+```bash
+cd open_wearable
+flutter run --dart-define=APP_STORE_PREVIEW=true
+```
+
+This launches the preview shell used for screenshots and demo flows instead of the normal Bluetooth-connected app.
+
 ## Contributing
 
 Contributor expectations and workflow rules are documented in [CONTRIBUTING.md](./CONTRIBUTING.md).
@@ -32,7 +67,7 @@ Contributor expectations and workflow rules are documented in [CONTRIBUTING.md](
 1. Clone this repository:
 
     ```bash
-    git clone https://github.com/OpenWearable/app.git
+    git clone https://github.com/OpenEarable/app.git
     ```
 
 2. Navigate to the project folder in your terminal.
@@ -42,6 +77,7 @@ Contributor expectations and workflow rules are documented in [CONTRIBUTING.md](
 4. Start the app on your phone:
 
     ```bash
+    cd open_wearable
     flutter run
     ```
 
@@ -56,7 +92,14 @@ Contributor expectations and workflow rules are documented in [CONTRIBUTING.md](
 3. Run the app in release mode:
 
     ```bash
+    cd open_wearable
     flutter run --release
     ```
 
     Select your phone as the target device from the list of connected devices.
+
+## Notes
+
+- Core app bootstrap is in [`open_wearable/lib/main.dart`](./open_wearable/lib/main.dart).
+- Route definitions are in [`open_wearable/lib/router.dart`](./open_wearable/lib/router.dart).
+- High-level feature state is primarily under [`open_wearable/lib/view_models/`](./open_wearable/lib/view_models/).
diff --git a/open_wearable/README.md b/open_wearable/README.md
index 653509be..1d680385 100644
--- a/open_wearable/README.md
+++ b/open_wearable/README.md
@@ -1,28 +1,5 @@
-# OpenWearable App Module
+# OpenWearables App Module
 
-Flutter application module for the OpenEarable app.
+This folder contains the main Flutter app for the repository.
 
-## Documentation
-
-High-level architecture and state-management docs live in [`docs/`](./docs/README.md).
-
-- [App Setup and Architecture](./docs/app-setup.md)
-- [State and Providers](./docs/state-and-providers.md)
-
-## Development Quick Start
-
-1. Install Flutter (stable channel).
-2. From this folder (`open_wearable/`), fetch dependencies:
-   ```bash
-   flutter pub get
-   ```
-3. Run on a connected device/emulator:
-   ```bash
-   flutter run
-   ```
-
-## Notes
-
-- Core app bootstrap is in `lib/main.dart`.
-- Route definitions are in `lib/router.dart`.
-- High-level feature state is primarily under `lib/view_models/`.
+For the primary project overview, setup instructions, and documentation links, see the [root README](../README.md).
diff --git a/open_wearable/android/app/src/main/AndroidManifest.xml b/open_wearable/android/app/src/main/AndroidManifest.xml
index eb49e63d..800532f0 100644
--- a/open_wearable/android/app/src/main/AndroidManifest.xml
+++ b/open_wearable/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <application android:label="OpenWearable" android:name="${applicationName}" android:icon="@mipmap/ic_launcher" android:enableOnBackInvokedCallback="true">
+    <application android:label="OpenWearables" android:name="${applicationName}" android:icon="@mipmap/ic_launcher" android:enableOnBackInvokedCallback="true">
         <activity android:name=".MainActivity" android:exported="true" android:launchMode="singleTop" android:taskAffinity="" android:theme="@style/LaunchTheme" android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode" android:hardwareAccelerated="true" android:windowSoftInputMode="adjustResize" android:screenOrientation="portrait">
             <!-- Specifies an Android theme to apply to this Activity as soon as
                  the Android process has started. This theme is visible to the user
diff --git a/open_wearable/android/app/src/main/kotlin/com/example/open_wearable/MainActivity.kt b/open_wearable/android/app/src/main/kotlin/edu/kit/teco/openwearables/MainActivity.kt
similarity index 97%
rename from open_wearable/android/app/src/main/kotlin/com/example/open_wearable/MainActivity.kt
rename to open_wearable/android/app/src/main/kotlin/edu/kit/teco/openwearables/MainActivity.kt
index 71435e35..31debb31 100644
--- a/open_wearable/android/app/src/main/kotlin/com/example/open_wearable/MainActivity.kt
+++ b/open_wearable/android/app/src/main/kotlin/edu/kit/teco/openwearables/MainActivity.kt
@@ -8,7 +8,7 @@ import io.flutter.plugin.common.MethodChannel
 
 class MainActivity : FlutterActivity() {
   companion object {
-    private const val SYSTEM_SETTINGS_CHANNEL = "edu.kit.teco.open_wearable/system_settings"
+    private const val SYSTEM_SETTINGS_CHANNEL = "edu.kit.teco.openWearable/system_settings"
   }
 
   override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
diff --git a/open_wearable/docs/README.md b/open_wearable/docs/README.md
index 35513b9d..0c0efc95 100644
--- a/open_wearable/docs/README.md
+++ b/open_wearable/docs/README.md
@@ -1,4 +1,4 @@
-# OpenWearable App Documentation
+# OpenWearables App Documentation
 
 This folder contains high-level documentation for the Flutter app in `open_wearable/`.
 
diff --git a/open_wearable/docs/app-setup.md b/open_wearable/docs/app-setup.md
index 67576794..e8970a00 100644
--- a/open_wearable/docs/app-setup.md
+++ b/open_wearable/docs/app-setup.md
@@ -1,6 +1,6 @@
 # App Setup and Architecture
 
-This document describes the high-level setup of the OpenWearable Flutter app (`open_wearable/`), including startup, routing, shell layout, and lifecycle behavior.
+This document describes the high-level setup of the OpenWearables Flutter app (`open_wearable/`), including startup, routing, shell layout, and lifecycle behavior.
 
 ## 1. Runtime Entry Point
 
diff --git a/open_wearable/docs/connectors/websocket-ipc-api.md b/open_wearable/docs/connectors/websocket-ipc-api.md
index ccc6abea..684b6c0f 100644
--- a/open_wearable/docs/connectors/websocket-ipc-api.md
+++ b/open_wearable/docs/connectors/websocket-ipc-api.md
@@ -1,6 +1,6 @@
 # WebSocket IPC API
 
-This document describes how to communicate with the OpenWearable WebSocket connector.
+This document describes how to communicate with the OpenWearables WebSocket connector.
 
 Python clients can use the [`open-wearables`](https://pypi.org/project/open-wearables/)
 package instead of implementing the JSON WebSocket protocol directly.
diff --git a/open_wearable/ios/Runner.xcodeproj/project.pbxproj b/open_wearable/ios/Runner.xcodeproj/project.pbxproj
index 0c280e6e..3783acab 100644
--- a/open_wearable/ios/Runner.xcodeproj/project.pbxproj
+++ b/open_wearable/ios/Runner.xcodeproj/project.pbxproj
@@ -510,6 +510,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				VERSIONING_SYSTEM = "apple-generic";
 			};
 			name = Profile;
@@ -695,6 +696,7 @@
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 				SWIFT_VERSION = 5.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				VERSIONING_SYSTEM = "apple-generic";
 			};
 			name = Debug;
@@ -718,6 +720,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				VERSIONING_SYSTEM = "apple-generic";
 			};
 			name = Release;
diff --git a/open_wearable/ios/Runner/AppDelegate.swift b/open_wearable/ios/Runner/AppDelegate.swift
index 1dffdfa3..a7fc0a72 100644
--- a/open_wearable/ios/Runner/AppDelegate.swift
+++ b/open_wearable/ios/Runner/AppDelegate.swift
@@ -33,8 +33,8 @@ import UIKit
   ) -> Bool {    
     let controller: FlutterViewController = window?.rootViewController as! FlutterViewController
     let openFolderChannel = FlutterMethodChannel(name: "edu.teco.open_folder", binaryMessenger: controller.binaryMessenger)
-    let systemSettingsChannel = FlutterMethodChannel(name: "edu.kit.teco.open_wearable/system_settings", binaryMessenger: controller.binaryMessenger)
-    lifecycleChannel = FlutterMethodChannel(name: "edu.kit.teco.open_wearable/lifecycle", binaryMessenger: controller.binaryMessenger)
+    let systemSettingsChannel = FlutterMethodChannel(name: "edu.kit.teco.openWearable/system_settings", binaryMessenger: controller.binaryMessenger)
+    lifecycleChannel = FlutterMethodChannel(name: "edu.kit.teco.openWearable/lifecycle", binaryMessenger: controller.binaryMessenger)
     
     openFolderChannel.setMethodCallHandler { (call: FlutterMethodCall, result: @escaping FlutterResult) in
       if call.method == "openFolder", let args = call.arguments as? [String: Any], let path = args["path"] as? String {
diff --git a/open_wearable/ios/Runner/Info.plist b/open_wearable/ios/Runner/Info.plist
index 3953846e..677c9991 100644
--- a/open_wearable/ios/Runner/Info.plist
+++ b/open_wearable/ios/Runner/Info.plist
@@ -7,7 +7,7 @@
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleDisplayName</key>
-	<string>Open Wearable</string>
+	<string>OpenWearables</string>
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIdentifier</key>
@@ -45,6 +45,10 @@
 	<string>This app requires access to device motion in order to provide sensor data.</string>
 	<key>NSMicrophoneUsageDescription</key>
 	<string>This app records microphone audio with local sensor recording sessions.</string>
+	<key>NSCameraUsageDescription</key>
+	<string>Camera access may be required by an iOS file selection component used to import firmware files. The app does not use the camera as part of its normal workflow.</string>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>Location access may be required by an iOS file selection component used to import firmware files. The app does not use location as part of its normal workflow.</string>
 	<key>NSPhotoLibraryUsageDescription</key>
 	<string>Needed for optional file selection functionality.</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
diff --git a/open_wearable/ios/ci_scripts/ci_post_clone.sh b/open_wearable/ios/ci_scripts/ci_post_clone.sh
index 03347e70..d011e6a8 100755
--- a/open_wearable/ios/ci_scripts/ci_post_clone.sh
+++ b/open_wearable/ios/ci_scripts/ci_post_clone.sh
@@ -27,7 +27,6 @@ echo "🟩 Install Flutter Dependencies"
 cd repository/open_wearable
 time flutter clean
 time flutter pub get
-time flutter pub upgrade
 
 echo "🟩 Install CocoaPods via Homebrew"
 time HOMEBREW_NO_AUTO_UPDATE=1 brew install cocoapods
@@ -39,4 +38,4 @@ cd ../
 echo "🟩 build iOS"
 time flutter build ios --release --no-codesign
 
-exit 0
\ No newline at end of file
+exit 0
diff --git a/open_wearable/lib/app_store_preview.dart b/open_wearable/lib/app_store_preview.dart
new file mode 100644
index 00000000..5e070750
--- /dev/null
+++ b/open_wearable/lib/app_store_preview.dart
@@ -0,0 +1,842 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_platform_widgets/flutter_platform_widgets.dart';
+import 'package:go_router/go_router.dart';
+import 'package:open_earable_flutter/open_earable_flutter.dart';
+import 'package:open_wearable/models/log_file_manager.dart';
+import 'package:open_wearable/models/wearable_connector.dart';
+import 'package:open_wearable/theme/app_theme.dart';
+import 'package:open_wearable/view_models/app_banner_controller.dart';
+import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
+import 'package:open_wearable/view_models/wearables_provider.dart';
+import 'package:open_wearable/widgets/devices/device_detail/device_detail_page.dart';
+import 'package:open_wearable/widgets/home_page.dart';
+import 'package:provider/provider.dart';
+import 'package:pub_semver/pub_semver.dart' as semver;
+
+/// App shell used only when building App Store screenshots.
+///
+/// The preview is selected at compile time with `APP_STORE_PREVIEW=true` and
+/// never changes the normal Bluetooth connection or sensor-data paths.
+class AppStorePreviewApp extends StatefulWidget {
+  final LogFileManager logFileManager;
+
+  const AppStorePreviewApp({
+    super.key,
+    required this.logFileManager,
+  });
+
+  @override
+  State<AppStorePreviewApp> createState() => _AppStorePreviewAppState();
+}
+
+class _AppStorePreviewAppState extends State<AppStorePreviewApp> {
+  late final AppStorePreviewWearable _wearable;
+  late final GoRouter _router;
+
+  @override
+  void initState() {
+    super.initState();
+    _wearable = AppStorePreviewWearable();
+    _router = GoRouter(
+      routes: [
+        GoRoute(
+          path: '/',
+          builder: (_, __) => const HomePage(),
+        ),
+        GoRoute(
+          path: '/device-detail',
+          builder: (_, state) {
+            final device = state.extra;
+            return DeviceDetailPage(
+              device: device is Wearable ? device : _wearable,
+            );
+          },
+        ),
+        GoRoute(
+          path: '/connect-devices',
+          redirect: (_, __) => '/?tab=devices',
+        ),
+        GoRoute(
+          path: '/view',
+          builder: (_, state) {
+            final view = state.extra;
+            return view is Widget
+                ? view
+                : const HomePage(
+                    initialSectionIndex: 2,
+                  );
+          },
+        ),
+        GoRoute(
+          path: '/settings/general',
+          redirect: (_, __) => '/?tab=settings',
+        ),
+      ],
+    );
+  }
+
+  @override
+  void dispose() {
+    _router.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return MultiProvider(
+      providers: [
+        ChangeNotifierProvider(
+          create: (_) {
+            final provider = WearablesProvider();
+            provider.addWearable(_wearable);
+            return provider;
+          },
+        ),
+        ChangeNotifierProvider(
+          create: (_) => FirmwareUpdateRequestProvider(),
+        ),
+        ChangeNotifierProxyProvider<WearablesProvider, SensorRecorderProvider>(
+          create: (_) => SensorRecorderProvider(),
+          update: (_, wearablesProvider, recorderProvider) {
+            final provider = recorderProvider ?? SensorRecorderProvider();
+            provider.synchronizeConnectedWearables(
+              wearablesProvider.wearables,
+            );
+            return provider;
+          },
+        ),
+        Provider<WearableConnector>(
+          create: (_) => WearableConnector(),
+        ),
+        ChangeNotifierProvider(
+          create: (_) => AppBannerController(),
+        ),
+        ChangeNotifierProvider.value(value: widget.logFileManager),
+      ],
+      child: PlatformProvider(
+        settings: PlatformSettingsData(
+          platformStyle: const PlatformStyleData(
+            ios: PlatformStyle.Material,
+            macos: PlatformStyle.Material,
+          ),
+        ),
+        builder: (context) => PlatformTheme(
+          materialLightTheme: AppTheme.lightTheme(),
+          materialDarkTheme: AppTheme.darkTheme(),
+          themeMode: ThemeMode.light,
+          builder: (context) => PlatformApp.router(
+            title: 'OpenWearables',
+            debugShowCheckedModeBanner: false,
+            localizationsDelegates: const <LocalizationsDelegate<dynamic>>[
+              DefaultMaterialLocalizations.delegate,
+              DefaultWidgetsLocalizations.delegate,
+              DefaultCupertinoLocalizations.delegate,
+            ],
+            routerConfig: _router,
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// A deterministic OpenEarable V2-style device for screenshot builds.
+class AppStorePreviewWearable extends Wearable
+    implements
+        SensorManager,
+        SensorConfigurationManager,
+        BatteryLevelStatus,
+        DeviceFirmwareVersion,
+        DeviceHardwareVersion,
+        DeviceIdentifier,
+        RgbLed,
+        StatusLed,
+        AudioModeManager,
+        MicrophoneManager<PreviewMicrophone>,
+        PowerSavingModeManager {
+  static const _sampleInterval = Duration(milliseconds: 20);
+  static final _disconnectNotifier = WearableDisconnectNotifier();
+  final List<Sensor> _sensors;
+  final StreamController<Map<SensorConfiguration, SensorConfigurationValue>>
+      _sensorConfigurationController = StreamController.broadcast();
+  final Map<SensorConfiguration, SensorConfigurationValue>
+      _configurationValues = {};
+  late final List<SensorConfiguration> _sensorConfigurations;
+
+  @override
+  final Set<AudioMode> availableAudioModes = const {
+    NormalMode(),
+    TransparencyMode(),
+    NoiseCancellationMode(),
+  };
+
+  @override
+  final Set<PreviewMicrophone> availableMicrophones = {
+    const PreviewMicrophone('INNER'),
+    const PreviewMicrophone('OUTER'),
+  };
+
+  final List<PowerSavingMode> _powerSavingModes = const [
+    PowerSavingMode(id: 0, name: 'Disabled'),
+    PowerSavingMode(id: 1, name: '30 minutes'),
+    PowerSavingMode(id: 2, name: '15 minutes'),
+    PowerSavingMode(id: 3, name: '5 minutes'),
+  ];
+
+  late AudioMode _audioMode = const NormalMode();
+  late PreviewMicrophone _microphone = const PreviewMicrophone('INNER');
+  late PowerSavingMode _powerSavingMode = _powerSavingModes.first;
+
+  AppStorePreviewWearable()
+      : _sensors = _buildSensors(),
+        super(
+          // Matches the firmware's `OpenEarable-%04X` advertising format.
+          name: 'OpenEarable-7E42',
+          disconnectNotifier: _disconnectNotifier,
+        ) {
+    _sensorConfigurations = _buildSensorConfigurations();
+    for (final configuration in _sensorConfigurations) {
+      final dynamic previewConfiguration = configuration;
+      _configurationValues[configuration] =
+          previewConfiguration.currentValue as SensorConfigurationValue;
+    }
+    _sensorConfigurationController.onListen = _publishConfigurationState;
+  }
+
+  List<SensorConfiguration> _buildSensorConfigurations() {
+    return [
+      _configuration(
+        name: '9-Axis IMU',
+        frequencies: const [25, 50, 100, 200, 400],
+        initialFrequency: 100,
+      ),
+      _configuration(
+        name: 'Microphones',
+        frequencies: const [8000, 16000, 24000, 32000],
+        initialFrequency: 16000,
+      ),
+      _configuration(
+        name: 'Pulse Oximeter',
+        frequencies: const [10, 25, 50, 100, 200],
+        initialFrequency: 50,
+      ),
+      _configuration(
+        name: 'Skin Temperature Sensor',
+        frequencies: const [1, 2, 5, 10],
+        initialFrequency: 5,
+      ),
+      _configuration(
+        name: 'Ear Canal Pressure Sensor',
+        frequencies: const [1, 5, 10, 25, 50],
+        initialFrequency: 25,
+      ),
+      _configuration(
+        name: 'Bone Conduction Accelerometer',
+        frequencies: const [100, 200, 400, 800, 1600],
+        initialFrequency: 400,
+      ),
+    ];
+  }
+
+  _PreviewSensorConfiguration _configuration({
+    required String name,
+    required List<double> frequencies,
+    required double initialFrequency,
+  }) {
+    final values = <_PreviewSensorConfigurationValue>[
+      _PreviewSensorConfigurationValue(frequencyHz: 0),
+      for (final frequency in frequencies) ...[
+        _PreviewSensorConfigurationValue(frequencyHz: frequency),
+        _PreviewSensorConfigurationValue(
+          frequencyHz: frequency,
+          options: {const StreamSensorConfigOption()},
+        ),
+        _PreviewSensorConfigurationValue(
+          frequencyHz: frequency,
+          options: {const RecordSensorConfigOption()},
+        ),
+        _PreviewSensorConfigurationValue(
+          frequencyHz: frequency,
+          options: {
+            const StreamSensorConfigOption(),
+            const RecordSensorConfigOption(),
+          },
+        ),
+      ],
+    ];
+    final initialValue = values.firstWhere(
+      (value) =>
+          value.frequencyHz == initialFrequency &&
+          value.options.any((option) => option is StreamSensorConfigOption),
+    );
+
+    return _PreviewSensorConfiguration(
+      name: name,
+      values: values,
+      initialValue: initialValue,
+      onChanged: _onSensorConfigurationChanged,
+    );
+  }
+
+  void _onSensorConfigurationChanged(
+    SensorConfiguration configuration,
+    SensorConfigurationValue value,
+  ) {
+    _configurationValues[configuration] = value;
+    _publishConfigurationState();
+  }
+
+  void _publishConfigurationState() {
+    if (!_sensorConfigurationController.isClosed) {
+      _sensorConfigurationController.add(Map.of(_configurationValues));
+    }
+  }
+
+  static List<Sensor> _buildSensors() {
+    return [
+      _PreviewSensor(
+        sensorName: 'Accelerometer',
+        chartTitle: 'Accelerometer',
+        shortChartTitle: 'Accel.',
+        axisNames: const ['X', 'Y', 'Z'],
+        axisUnits: const ['m/s²', 'm/s²', 'm/s²'],
+        sampleValues: _accelerometerValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'Gyroscope',
+        chartTitle: 'Gyroscope',
+        shortChartTitle: 'Gyro.',
+        axisNames: const ['X', 'Y', 'Z'],
+        axisUnits: const ['°/s', '°/s', '°/s'],
+        sampleValues: _gyroscopeValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'Magnetometer',
+        chartTitle: 'Magnetometer',
+        shortChartTitle: 'Mag.',
+        axisNames: const ['X', 'Y', 'Z'],
+        axisUnits: const ['µT', 'µT', 'µT'],
+        sampleValues: _magnetometerValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'Pressure',
+        chartTitle: 'Pressure',
+        shortChartTitle: 'Pressure',
+        axisNames: const ['Pressure'],
+        axisUnits: const ['hPa'],
+        sampleValues: (seconds) => [_pressureValue(seconds)],
+      ),
+      _PreviewSensor(
+        sensorName: 'Skin Temperature',
+        chartTitle: 'Skin Temperature',
+        shortChartTitle: 'Skin temp.',
+        axisNames: const ['Temperature'],
+        axisUnits: const ['°C'],
+        sampleValues: (seconds) => [_skinTemperatureValue(seconds)],
+      ),
+      _PreviewSensor(
+        sensorName: 'Barometer Temperature',
+        chartTitle: 'Barometer Temperature',
+        shortChartTitle: 'Baro temp.',
+        axisNames: const ['Temperature'],
+        axisUnits: const ['°C'],
+        sampleValues: (seconds) => [_barometerTemperatureValue(seconds)],
+      ),
+      _PreviewSensor(
+        sensorName: 'Bone Conduction Accelerometer',
+        chartTitle: 'Bone Conduction',
+        shortChartTitle: 'Bone accel.',
+        axisNames: const ['X', 'Y', 'Z'],
+        axisUnits: const ['g', 'g', 'g'],
+        sampleValues: _boneConductionValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'PPG RED',
+        chartTitle: 'PPG - RED',
+        shortChartTitle: 'PPG RED',
+        axisNames: const ['RED'],
+        axisUnits: const ['ADC'],
+        sampleValues: _ppgRedValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'PPG IR',
+        chartTitle: 'PPG - IR',
+        shortChartTitle: 'PPG IR',
+        axisNames: const ['IR'],
+        axisUnits: const ['ADC'],
+        sampleValues: _ppgIrValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'PPG GREEN',
+        chartTitle: 'PPG - GREEN',
+        shortChartTitle: 'PPG GREEN',
+        axisNames: const ['GREEN'],
+        axisUnits: const ['ADC'],
+        sampleValues: _ppgGreenValues,
+      ),
+      _PreviewSensor(
+        sensorName: 'PPG AMBIENT',
+        chartTitle: 'PPG - AMBIENT',
+        shortChartTitle: 'PPG AMBIENT',
+        axisNames: const ['AMBIENT'],
+        axisUnits: const ['ADC'],
+        sampleValues: _ppgAmbientValues,
+      ),
+    ];
+  }
+
+  /// Simulates gravity-compensated acceleration for a device mounted a short
+  /// distance from the head's rotation center. At rest, all axes sit near 0.
+  static List<double> _accelerometerValues(double seconds) {
+    const derivativeWindowSeconds = 0.12;
+    const leverArm = [0.08, -0.06, 0.10];
+    final angularVelocity = _angularVelocityAt(seconds);
+    final beforeVelocity =
+        _angularVelocityAt(seconds - derivativeWindowSeconds);
+    final afterVelocity = _angularVelocityAt(seconds + derivativeWindowSeconds);
+    final angularAcceleration = [
+      (afterVelocity[0] - beforeVelocity[0]) / (2 * derivativeWindowSeconds),
+      (afterVelocity[1] - beforeVelocity[1]) / (2 * derivativeWindowSeconds),
+      (afterVelocity[2] - beforeVelocity[2]) / (2 * derivativeWindowSeconds),
+    ];
+    final tangentialAcceleration = _cross(angularAcceleration, leverArm);
+    final centripetalAcceleration =
+        _cross(angularVelocity, _cross(angularVelocity, leverArm));
+
+    return [
+      tangentialAcceleration[0] +
+          centripetalAcceleration[0] +
+          _accelerometerMeasurementNoise(seconds, 40),
+      tangentialAcceleration[1] +
+          centripetalAcceleration[1] +
+          _accelerometerMeasurementNoise(seconds, 41),
+      tangentialAcceleration[2] +
+          centripetalAcceleration[2] +
+          _accelerometerMeasurementNoise(seconds, 42),
+    ];
+  }
+
+  static double _accelerometerMeasurementNoise(double seconds, int seed) {
+    return 0.055 * _smoothRandom(seconds, seed, 13) +
+        0.025 * _smoothRandom(seconds, seed + 10, 19);
+  }
+
+  /// These sensors are effectively stationary in the preview. Only a small
+  /// sample-level measurement error is visible instead of simulated movement.
+  static double _pressureValue(double seconds) {
+    return 1012.8 + 0.0015 * _stationarySensorNoise(seconds, 9);
+  }
+
+  static double _skinTemperatureValue(double seconds) {
+    return 34.2 + 0.008 * _stationarySensorNoise(seconds, 50);
+  }
+
+  static double _barometerTemperatureValue(double seconds) {
+    return 32.8 + 0.006 * _stationarySensorNoise(seconds, 52);
+  }
+
+  static double _stationarySensorNoise(double seconds, int seed) {
+    return _smoothRandom(seconds, seed, 1.0);
+  }
+
+  /// Bone-conduction acceleration includes the same head movement measured by
+  /// the IMU, expressed in g, together with the higher-frequency local
+  /// vibrations captured at the device contact point.
+  static List<double> _boneConductionValues(double seconds) {
+    const gravity = 9.80665;
+    final headMotion = _accelerometerValues(seconds);
+
+    return [
+      headMotion[0] / gravity + 0.018 * _sensorNoise(seconds, 60),
+      headMotion[1] / gravity + 0.015 * _sensorNoise(seconds, 61),
+      headMotion[2] / gravity + 0.020 * _sensorNoise(seconds, 62),
+    ];
+  }
+
+  /// Rotates a stable local Earth-field vector into device coordinates using
+  /// the same roll, pitch, and yaw that drive the other motion sensors.
+  static List<double> _magnetometerValues(double seconds) {
+    const earthField = [21.5, -3.0, 43.0];
+    final orientation = _orientationAt(seconds);
+    final cosYaw = math.cos(orientation.yaw);
+    final sinYaw = math.sin(orientation.yaw);
+    final cosPitch = math.cos(orientation.pitch);
+    final sinPitch = math.sin(orientation.pitch);
+    final cosRoll = math.cos(orientation.roll);
+    final sinRoll = math.sin(orientation.roll);
+
+    final yawX = cosYaw * earthField[0] + sinYaw * earthField[1];
+    final yawY = -sinYaw * earthField[0] + cosYaw * earthField[1];
+    final pitchX = cosPitch * yawX - sinPitch * earthField[2];
+    final pitchZ = sinPitch * yawX + cosPitch * earthField[2];
+
+    return [
+      pitchX + 0.25 * _smoothRandom(seconds, 6, 10),
+      cosRoll * yawY + sinRoll * pitchZ + 0.25 * _smoothRandom(seconds, 7, 10),
+      -sinRoll * yawY + cosRoll * pitchZ + 0.25 * _smoothRandom(seconds, 8, 10),
+    ];
+  }
+
+  /// Calculates angular velocity from the same roll/pitch used by the
+  /// accelerometer. The components are expressed in the device coordinate
+  /// system and converted from radians to degrees per second.
+  static List<double> _gyroscopeValues(double seconds) {
+    const radiansToDegrees = 180 / math.pi;
+    final angularVelocity = _angularVelocityAt(seconds);
+
+    return [
+      angularVelocity[0] * radiansToDegrees +
+          0.25 * _smoothRandom(seconds, 20, 3.5),
+      angularVelocity[1] * radiansToDegrees +
+          0.25 * _smoothRandom(seconds, 21, 3.5),
+      angularVelocity[2] * radiansToDegrees +
+          0.25 * _smoothRandom(seconds, 22, 3.5),
+    ];
+  }
+
+  static List<double> _angularVelocityAt(double seconds) {
+    const derivativeWindowSeconds = 0.12;
+    final before = _orientationAt(seconds - derivativeWindowSeconds);
+    final current = _orientationAt(seconds);
+    final after = _orientationAt(seconds + derivativeWindowSeconds);
+    final rollRate = (after.roll - before.roll) / (2 * derivativeWindowSeconds);
+    final pitchRate =
+        (after.pitch - before.pitch) / (2 * derivativeWindowSeconds);
+    final yawRate = (after.yaw - before.yaw) / (2 * derivativeWindowSeconds);
+
+    return [
+      rollRate - yawRate * math.sin(current.pitch),
+      pitchRate * math.cos(current.roll) +
+          yawRate * math.sin(current.roll) * math.cos(current.pitch),
+      -pitchRate * math.sin(current.roll) +
+          yawRate * math.cos(current.roll) * math.cos(current.pitch),
+    ];
+  }
+
+  static List<double> _cross(List<double> first, List<double> second) {
+    return [
+      first[1] * second[2] - first[2] * second[1],
+      first[2] * second[0] - first[0] * second[2],
+      first[0] * second[1] - first[1] * second[0],
+    ];
+  }
+
+  static _PreviewOrientation _orientationAt(double seconds) {
+    return _PreviewOrientation(
+      pitch: 0.52 +
+          0.34 * _smoothRandom(seconds, 0, 0.34) +
+          0.08 * _smoothRandom(seconds, 10, 2.2) +
+          0.020 * _smoothRandom(seconds, 30, 6.5),
+      roll: 0.72 +
+          0.36 * _smoothRandom(seconds, 1, 0.28) +
+          0.07 * _smoothRandom(seconds, 11, 2.7) +
+          0.024 * _smoothRandom(seconds, 31, 6),
+      yaw: 0.25 +
+          0.50 * _smoothRandom(seconds, 2, 0.12) +
+          0.16 * _smoothRandom(seconds, 12, 0.85) +
+          0.020 * _smoothRandom(seconds, 32, 4),
+    );
+  }
+
+  /// Produces band-limited, deterministic noise so screenshots are repeatable
+  /// without making the live traces look periodic.
+  static double _sensorNoise(double seconds, int seed) {
+    return 0.50 * _smoothRandom(seconds, seed, 0.45) +
+        0.31 * _smoothRandom(seconds, seed + 17, 2.6) +
+        0.19 * _smoothRandom(seconds, seed + 31, 14.5);
+  }
+
+  static double _smoothRandom(double seconds, int seed, double frequency) {
+    final position = seconds * frequency;
+    final leftIndex = position.floor();
+    final fraction = position - leftIndex;
+    final easedFraction = fraction * fraction * (3 - 2 * fraction);
+    final start = _randomAt(leftIndex, seed);
+    final end = _randomAt(leftIndex + 1, seed);
+    return start + (end - start) * easedFraction;
+  }
+
+  static double _randomAt(int index, int seed) {
+    var value = index ^ (seed * 0x9E3779B9);
+    value = (value ^ (value >> 16)) * 0x45D9F3B;
+    value = (value ^ (value >> 16)) * 0x45D9F3B;
+    value ^= value >> 16;
+    return (value & 0x7FFFFFFF) / 0x3FFFFFFF - 1;
+  }
+
+  static List<double> _ppgValues(double seconds) {
+    final heartbeatPosition =
+        seconds * 1.16 + 0.07 * _smoothRandom(seconds, 41, 0.2);
+    final phase = heartbeatPosition - heartbeatPosition.floor();
+    final systolicPeak = math.exp(-math.pow((phase - 0.17) / 0.07, 2));
+    final dicroticWave = 0.32 * math.exp(-math.pow((phase - 0.48) / 0.11, 2));
+    final pulse = systolicPeak + dicroticWave;
+    final contact = 1 + 0.035 * _smoothRandom(seconds, 42, 0.12);
+    final motionArtifact = 1800 * _sensorNoise(seconds, 43);
+
+    return [
+      228000 +
+          34000 * contact * pulse +
+          motionArtifact +
+          950 * _sensorNoise(seconds, 44),
+      194000 +
+          31000 * contact * pulse +
+          0.85 * motionArtifact +
+          800 * _sensorNoise(seconds, 45),
+      126000 +
+          17500 * contact * pulse +
+          0.70 * motionArtifact +
+          700 * _sensorNoise(seconds, 46),
+      4800 +
+          900 * _smoothRandom(seconds, 47, 0.08) +
+          550 * _sensorNoise(seconds, 48),
+    ];
+  }
+
+  static List<double> _ppgRedValues(double seconds) => [_ppgValues(seconds)[0]];
+
+  static List<double> _ppgIrValues(double seconds) => [_ppgValues(seconds)[1]];
+
+  static List<double> _ppgGreenValues(double seconds) =>
+      [_ppgValues(seconds)[2]];
+
+  static List<double> _ppgAmbientValues(double seconds) =>
+      [_ppgValues(seconds)[3]];
+
+  @override
+  String get deviceId => 'F4:12:FA:00:7E:42';
+
+  @override
+  List<Sensor> get sensors => _sensors;
+
+  @override
+  List<SensorConfiguration> get sensorConfigurations => _sensorConfigurations;
+
+  @override
+  Stream<Map<SensorConfiguration, SensorConfigurationValue>>
+      get sensorConfigurationStream => _sensorConfigurationController.stream;
+
+  @override
+  Future<String?> readDeviceIdentifier() async => 'OE2-7E42';
+
+  @override
+  Future<void> writeLedColor({
+    required int r,
+    required int g,
+    required int b,
+  }) async {}
+
+  @override
+  Future<void> showStatus(bool status) async {}
+
+  @override
+  void setAudioMode(AudioMode audioMode) {
+    _audioMode = audioMode;
+  }
+
+  @override
+  Future<AudioMode> getAudioMode() async => _audioMode;
+
+  @override
+  void setMicrophone(PreviewMicrophone microphone) {
+    _microphone = microphone;
+  }
+
+  @override
+  Future<PreviewMicrophone> getMicrophone() async => _microphone;
+
+  @override
+  Future<List<PowerSavingMode>> readSupportedPowerSavingModes() async =>
+      _powerSavingModes;
+
+  @override
+  Future<PowerSavingMode> readPowerSavingMode() async => _powerSavingMode;
+
+  @override
+  Future<void> setPowerSavingMode(PowerSavingMode mode) async {
+    _powerSavingMode = mode;
+  }
+
+  @override
+  Future<int> readBatteryPercentage() async => 87;
+
+  @override
+  Stream<int> get batteryPercentageStream => Stream<int>.value(87);
+
+  @override
+  Future<String?> readDeviceFirmwareVersion() async => '2.2.0';
+
+  @override
+  Future<semver.Version?> readFirmwareVersionNumber() async =>
+      semver.Version(2, 2, 0);
+
+  @override
+  semver.VersionConstraint get supportedFirmwareRange =>
+      semver.VersionConstraint.any;
+
+  @override
+  Future<FirmwareSupportStatus> checkFirmwareSupport() async =>
+      FirmwareSupportStatus.supported;
+
+  @override
+  Future<String?> readDeviceHardwareVersion() async => 'V2.1';
+
+  @override
+  Future<void> disconnect() async {
+    _disconnectNotifier.notifyListeners();
+  }
+
+  @override
+  String? getWearableIconPath({
+    bool darkmode = false,
+    WearableIconVariant variant = WearableIconVariant.single,
+  }) {
+    const basePath =
+        'packages/open_earable_flutter/assets/wearable_icons/open_earable_v2';
+    if (darkmode) {
+      return '$basePath/icon_no_text_white.svg';
+    }
+    return '$basePath/icon_no_text.svg';
+  }
+}
+
+class _PreviewSensorConfiguration
+    extends SensorFrequencyConfiguration<_PreviewSensorConfigurationValue>
+    implements
+        ConfigurableSensorConfiguration<_PreviewSensorConfigurationValue> {
+  final void Function(SensorConfiguration, SensorConfigurationValue) _onChanged;
+  _PreviewSensorConfigurationValue _currentValue;
+
+  @override
+  final Set<SensorConfigurationOption> availableOptions = {
+    const StreamSensorConfigOption(),
+    const RecordSensorConfigOption(),
+  };
+
+  _PreviewSensorConfiguration({
+    required super.name,
+    required super.values,
+    required _PreviewSensorConfigurationValue initialValue,
+    required void Function(SensorConfiguration, SensorConfigurationValue)
+        onChanged,
+  })  : _currentValue = initialValue,
+        _onChanged = onChanged,
+        super(offValue: values.first);
+
+  _PreviewSensorConfigurationValue get currentValue => _currentValue;
+
+  @override
+  void setConfiguration(_PreviewSensorConfigurationValue configuration) {
+    _currentValue = configuration;
+    _onChanged(this, configuration);
+  }
+}
+
+class _PreviewSensorConfigurationValue extends SensorFrequencyConfigurationValue
+    implements ConfigurableSensorConfigurationValue {
+  @override
+  final Set<SensorConfigurationOption> options;
+
+  _PreviewSensorConfigurationValue({
+    required super.frequencyHz,
+    this.options = const {},
+  }) : super(key: '$frequencyHz Hz');
+
+  @override
+  _PreviewSensorConfigurationValue withoutOptions() {
+    return _PreviewSensorConfigurationValue(frequencyHz: frequencyHz);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is _PreviewSensorConfigurationValue &&
+        other.frequencyHz == frequencyHz &&
+        _sameOptionNames(other.options, options);
+  }
+
+  @override
+  int get hashCode => Object.hash(
+        frequencyHz,
+        options.map((option) => option.name).toSet().join('|'),
+      );
+
+  static bool _sameOptionNames(
+    Set<SensorConfigurationOption> first,
+    Set<SensorConfigurationOption> second,
+  ) {
+    return first.length == second.length && first.containsAll(second);
+  }
+}
+
+class PreviewMicrophone extends Microphone {
+  const PreviewMicrophone(String key) : super(key: key);
+}
+
+class _PreviewOrientation {
+  final double pitch;
+  final double roll;
+  final double yaw;
+
+  const _PreviewOrientation({
+    required this.pitch,
+    required this.roll,
+    required this.yaw,
+  });
+}
+
+class _PreviewSensor extends Sensor<SensorDoubleValue> {
+  static const _historySamples = 250;
+  final List<String> _axisNames;
+  final List<String> _axisUnits;
+  final List<double> Function(double seconds) _sampleValues;
+
+  _PreviewSensor({
+    required super.sensorName,
+    required super.chartTitle,
+    required super.shortChartTitle,
+    required List<String> axisNames,
+    required List<String> axisUnits,
+    required List<double> Function(double seconds) sampleValues,
+  })  : _axisNames = axisNames,
+        _axisUnits = axisUnits,
+        _sampleValues = sampleValues,
+        super(timestampExponent: -3);
+
+  @override
+  List<String> get axisNames => _axisNames;
+
+  @override
+  List<String> get axisUnits => _axisUnits;
+
+  @override
+  Stream<SensorDoubleValue> get sensorStream async* {
+    final startedAt = DateTime.now().millisecondsSinceEpoch;
+
+    // Seed the five-second window so a screenshot is ready on the first frame.
+    for (var index = _historySamples; index >= 0; index--) {
+      final timestamp = startedAt -
+          index * AppStorePreviewWearable._sampleInterval.inMilliseconds;
+      yield _valueAt(timestamp);
+    }
+
+    var sampleIndex = 1;
+    while (true) {
+      await Future<void>.delayed(AppStorePreviewWearable._sampleInterval);
+      final timestamp = startedAt +
+          sampleIndex * AppStorePreviewWearable._sampleInterval.inMilliseconds;
+      sampleIndex++;
+      yield _valueAt(timestamp);
+    }
+  }
+
+  SensorDoubleValue _valueAt(int timestamp) {
+    return SensorDoubleValue(
+      values: _sampleValues(timestamp / Duration.millisecondsPerSecond),
+      timestamp: timestamp,
+    );
+  }
+}
diff --git a/open_wearable/lib/main.dart b/open_wearable/lib/main.dart
index 7abab9c5..6e04d00d 100644
--- a/open_wearable/lib/main.dart
+++ b/open_wearable/lib/main.dart
@@ -19,6 +19,7 @@ import 'package:open_wearable/models/fota_post_update_verification.dart';
 import 'package:open_wearable/models/permissions_helper.dart';
 import 'package:open_wearable/models/wearable_connector.dart'
     hide WearableEvent;
+import 'package:open_wearable/app_store_preview.dart';
 import 'package:open_wearable/router.dart';
 import 'package:open_wearable/theme/app_theme.dart';
 import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
@@ -37,12 +38,20 @@ import 'models/logger.dart';
 import 'view_models/app_banner_controller.dart';
 import 'view_models/wearables_provider.dart';
 
+const bool _isAppStorePreview = bool.fromEnvironment('APP_STORE_PREVIEW');
+
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
   LogFileManager logFileManager = await LogFileManager.create();
   final wearableConnector = WearableConnector();
   initOpenWearableLogger(logFileManager.libLogger);
   initLogger(logFileManager.logger);
+
+  if (_isAppStorePreview) {
+    runApp(AppStorePreviewApp(logFileManager: logFileManager));
+    return;
+  }
+
   await AutoConnectPreferences.initialize();
   await AppShutdownSettings.initialize();
   await ConnectorSettings.initialize(wearableConnector: wearableConnector);
@@ -964,7 +973,7 @@ class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
               DefaultWidgetsLocalizations.delegate,
               DefaultCupertinoLocalizations.delegate,
             ],
-            title: 'Open Wearable',
+            title: 'OpenWearables',
           ),
         ),
       ),
diff --git a/open_wearable/lib/models/app_background_execution_bridge.dart b/open_wearable/lib/models/app_background_execution_bridge.dart
index 6430f1fb..70a3088f 100644
--- a/open_wearable/lib/models/app_background_execution_bridge.dart
+++ b/open_wearable/lib/models/app_background_execution_bridge.dart
@@ -6,7 +6,7 @@ import 'package:flutter/services.dart';
 /// recorder-related handoff.
 class AppBackgroundExecutionBridge {
   static const MethodChannel _channel = MethodChannel(
-    'edu.kit.teco.open_wearable/lifecycle',
+    'edu.kit.teco.openWearable/lifecycle',
   );
 
   static Future<void> beginSensorShutdownWindow() async {
diff --git a/open_wearable/lib/widgets/devices/connect_devices_page.dart b/open_wearable/lib/widgets/devices/connect_devices_page.dart
index 7608a9f0..8cb2579f 100644
--- a/open_wearable/lib/widgets/devices/connect_devices_page.dart
+++ b/open_wearable/lib/widgets/devices/connect_devices_page.dart
@@ -205,7 +205,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
                   ),
                   title: const Text('Enable Microphone'),
                   subtitle: const Text(
-                    'OpenWearable can record audio from the device microphone for synchronized audio data. Grant microphone access to enable this.',
+                    'OpenWearables can record audio from the device microphone for synchronized audio data. Grant microphone access to enable this.',
                   ),
                   trailing: PlatformElevatedButton(
                     onPressed: _requestMicPermission,
diff --git a/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart b/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
index 88ee4fd2..5b948d99 100644
--- a/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
+++ b/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
@@ -39,7 +39,7 @@ class DeviceDetailPage extends StatefulWidget {
 
 class _DeviceDetailPageState extends State<DeviceDetailPage> {
   static const MethodChannel _systemSettingsChannel = MethodChannel(
-    'edu.kit.teco.open_wearable/system_settings',
+    'edu.kit.teco.openWearable/system_settings',
   );
 
   StreamSubscription<List<Type>>? _capabilitySubscription;
diff --git a/open_wearable/lib/widgets/home_page.dart b/open_wearable/lib/widgets/home_page.dart
index b3ec8976..30c198bb 100644
--- a/open_wearable/lib/widgets/home_page.dart
+++ b/open_wearable/lib/widgets/home_page.dart
@@ -269,7 +269,7 @@ class _AppRailLogo extends StatelessWidget {
         height: 32,
         fit: BoxFit.cover,
         filterQuality: FilterQuality.medium,
-        semanticLabel: 'OpenWearable app icon',
+        semanticLabel: 'OpenWearables app icon',
       ),
     );
 
@@ -283,7 +283,7 @@ class _AppRailLogo extends StatelessWidget {
         icon,
         const SizedBox(width: 12),
         Text(
-          'OpenWearable',
+          'OpenWearables',
           style: Theme.of(context).textTheme.titleMedium,
         ),
       ],
diff --git a/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart b/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
index e30f8961..09f81a78 100644
--- a/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
+++ b/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
@@ -60,7 +60,7 @@ class PermissionsWelcomePage extends StatelessWidget {
                         ),
                         const SizedBox(height: 20),
                         Text(
-                          'Welcome to OpenWearable',
+                          'Welcome to OpenWearables',
                           style: theme.textTheme.headlineSmall?.copyWith(
                             fontWeight: FontWeight.w700,
                           ),
@@ -68,7 +68,7 @@ class PermissionsWelcomePage extends StatelessWidget {
                         ),
                         const SizedBox(height: 12),
                         Text(
-                          'OpenWearable supports research and development of the next generation wearable applications by helping you connect devices, inspect live sensor data, and record synchronized sessions.',
+                          'OpenWearables supports research and development of the next generation wearable applications by helping you connect devices, inspect live sensor data, and record synchronized sessions.',
                           style: theme.textTheme.bodyMedium,
                           textAlign: TextAlign.center,
                         ),
@@ -151,7 +151,7 @@ class _SupportEmailTextState extends State<_SupportEmailText> {
         children: [
           const TextSpan(
             text:
-                'Thank you for trusting OpenWearable. If you have any questions or run into problems, reach out to ',
+                'Thank you for trusting OpenWearables. If you have any questions or run into problems, reach out to ',
           ),
           TextSpan(
             text: 'info@openwearables.com',
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_io.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_io.dart
index ef30f037..d3722d8e 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_io.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_io.dart
@@ -7,7 +7,7 @@ Future<void> localRecorderShareFile(LocalRecorderRecordingFile file) async {
   await SharePlus.instance.share(
     ShareParams(
       files: [XFile(file.path)],
-      subject: 'OpenWearable Recording File',
+      subject: 'OpenWearables Recording File',
     ),
   );
 }
@@ -18,7 +18,7 @@ Future<void> localRecorderShareFolder(
   await SharePlus.instance.share(
     ShareParams(
       files: folder.files.map((entry) => XFile(entry.path)).toList(),
-      subject: 'OpenWearable Recording',
+      subject: 'OpenWearables Recording',
     ),
   );
 }
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_web.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_web.dart
index 7dd4803c..7cdfcf7a 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_web.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_file_actions_web.dart
@@ -17,7 +17,7 @@ Future<void> localRecorderShareFile(LocalRecorderRecordingFile file) async {
           mimeType: file.mimeType,
         ),
       ],
-      subject: 'OpenWearable Recording File',
+      subject: 'OpenWearables Recording File',
     ),
   );
 }
@@ -40,7 +40,7 @@ Future<void> localRecorderShareFolder(
   await SharePlus.instance.share(
     ShareParams(
       files: files,
-      subject: 'OpenWearable Recording',
+      subject: 'OpenWearables Recording',
     ),
   );
 }
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_io.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_io.dart
index b3d4212c..6f2d1fbb 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_io.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_io.dart
@@ -43,7 +43,7 @@ Future<String?> pickRecordingDirectory() async {
   if (kIsWeb) return null;
 
   final recordingName =
-      'OpenWearable_Recording_${DateTime.now().toIso8601String().replaceAll(':', '-')}';
+      'OpenWearables_Recording_${DateTime.now().toIso8601String().replaceAll(':', '-')}';
 
   final rootDir = await _getRecordingsRootDirectory();
   if (rootDir == null) return null;
@@ -67,7 +67,11 @@ Future<List<LocalRecorderRecordingFolder>> listRecordingFolders() async {
   final folders = root
       .listSync()
       .whereType<Directory>()
-      .where((entity) => entity.path.contains('OpenWearable_Recording'))
+      .where(
+        (entity) => entity.path.contains(
+          'OpenWearable', // Not checking for "OpenWearables_Recording" to avoid losing existing recordings
+        ),
+      )
       .map(_directoryToFolder)
       .toList()
     ..sort((a, b) => b.updatedAt.compareTo(a.updatedAt));
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_web.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_web.dart
index 4d668f2a..0339b8da 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_web.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_storage_web.dart
@@ -113,7 +113,7 @@ LocalRecorderRecordingFolder _createFolder({
 
 String _recordingFolderName() {
   final timestamp = DateTime.now().toIso8601String();
-  return 'OpenWearable_Recording_$timestamp';
+  return 'OpenWearables_Recording_$timestamp';
 }
 
 List<LocalRecorderRecordingFolder> _readFolders(SharedPreferences prefs) {
diff --git a/open_wearable/lib/widgets/sensors/values/sensor_chart.dart b/open_wearable/lib/widgets/sensors/values/sensor_chart.dart
index 6885a31f..e23c05f7 100644
--- a/open_wearable/lib/widgets/sensors/values/sensor_chart.dart
+++ b/open_wearable/lib/widgets/sensors/values/sensor_chart.dart
@@ -516,6 +516,8 @@ class _SensorChartState extends State<SensorChart> {
     if (name == 'r' || name == 'red') return Colors.red;
     if (name == 'g' || name == 'green') return Colors.green;
     if (name == 'b' || name == 'blue') return Colors.blue;
+    if (name == 'ir' || name == 'infrared') return const Color(0xFF9C27B0);
+    if (name == 'ambient') return const Color(0xFF607D8B);
     if (name.contains('temp')) return const Color(0xFFFB8500);
     if (name.contains('pressure')) return const Color(0xFF6C63FF);
 
diff --git a/open_wearable/lib/widgets/settings/connectors_page.dart b/open_wearable/lib/widgets/settings/connectors_page.dart
index c65dfc09..ae64dd36 100644
--- a/open_wearable/lib/widgets/settings/connectors_page.dart
+++ b/open_wearable/lib/widgets/settings/connectors_page.dart
@@ -329,7 +329,7 @@ class _ConnectorsPageState extends State<ConnectorsPage> {
                         ),
                         const SizedBox(height: 4),
                         Text(
-                          'Expose OpenWearable features for external tools.',
+                          'Expose OpenWearables features for external tools.',
                           style:
                               Theme.of(context).textTheme.bodySmall?.copyWith(
                                     color: Theme.of(context)
@@ -415,7 +415,7 @@ class _ConnectorsPageState extends State<ConnectorsPage> {
                       ),
                       const SizedBox(height: 2),
                       Text(
-                        'Expose the OpenWearable Flutter API over JSON messages.',
+                        'Expose the OpenWearables Flutter API over JSON messages.',
                         style: Theme.of(context).textTheme.bodySmall?.copyWith(
                               color: colorScheme.onSurfaceVariant,
                             ),
diff --git a/open_wearable/linux/runner/my_application.cc b/open_wearable/linux/runner/my_application.cc
index 6ed6c419..76e1a42f 100644
--- a/open_wearable/linux/runner/my_application.cc
+++ b/open_wearable/linux/runner/my_application.cc
@@ -40,11 +40,11 @@ static void my_application_activate(GApplication* application) {
   if (use_header_bar) {
     GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
     gtk_widget_show(GTK_WIDGET(header_bar));
-    gtk_header_bar_set_title(header_bar, "open_wearable");
+    gtk_header_bar_set_title(header_bar, "OpenWearables");
     gtk_header_bar_set_show_close_button(header_bar, TRUE);
     gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
   } else {
-    gtk_window_set_title(window, "open_wearable");
+    gtk_window_set_title(window, "OpenWearables");
   }
 
   gtk_window_set_default_size(window, 1280, 720);
diff --git a/open_wearable/macos/Runner.xcodeproj/project.pbxproj b/open_wearable/macos/Runner.xcodeproj/project.pbxproj
index 7abbfeac..12000fa5 100644
--- a/open_wearable/macos/Runner.xcodeproj/project.pbxproj
+++ b/open_wearable/macos/Runner.xcodeproj/project.pbxproj
@@ -485,9 +485,9 @@
 			baseConfigurationReference = 96216F23D824FB4DBC4D1651 /* Pods-RunnerTests.debug.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
 				GENERATE_INFOPLIST_FILE = YES;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				PRODUCT_BUNDLE_IDENTIFIER = edu.kit.teco.openWearable.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
@@ -500,9 +500,9 @@
 			baseConfigurationReference = 17A273C9BAD6C6191A4621D3 /* Pods-RunnerTests.release.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
 				GENERATE_INFOPLIST_FILE = YES;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				PRODUCT_BUNDLE_IDENTIFIER = edu.kit.teco.openWearable.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
@@ -515,9 +515,9 @@
 			baseConfigurationReference = 255AE7CCB573329186BA4E3F /* Pods-RunnerTests.profile.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
 				GENERATE_INFOPLIST_FILE = YES;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)";
 				PRODUCT_BUNDLE_IDENTIFIER = edu.kit.teco.openWearable.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
diff --git a/open_wearable/macos/Runner/Info.plist b/open_wearable/macos/Runner/Info.plist
index 8fe38f45..c06df168 100644
--- a/open_wearable/macos/Runner/Info.plist
+++ b/open_wearable/macos/Runner/Info.plist
@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>CFBundleDisplayName</key>
+	<string>OpenWearables</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleExecutable</key>
@@ -23,9 +25,9 @@
 	<key>LSMinimumSystemVersion</key>
 	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
 	<key>NSBluetoothAlwaysUsageDescription</key>
-	<string>OpenWearable requires Bluetooth access to connect to your wearable device.</string>
+	<string>OpenWearables requires Bluetooth access to connect to your wearable device.</string>
 	<key>NSBluetoothPeripheralUsageDescription</key>
-	<string>OpenWearable requires Bluetooth access to connect to your wearable device.</string>
+	<string>OpenWearables requires Bluetooth access to connect to your wearable device.</string>
 	<key>NSMicrophoneUsageDescription</key>
 	<string>This app records microphone audio with local sensor recording sessions.</string>
 	<key>NSHumanReadableCopyright</key>
diff --git a/open_wearable/web/index.html b/open_wearable/web/index.html
index e0ac89c4..91cc3695 100644
--- a/open_wearable/web/index.html
+++ b/open_wearable/web/index.html
@@ -60,14 +60,14 @@
 
   <meta charset="UTF-8">
   <meta content="IE=Edge" http-equiv="X-UA-Compatible">
-  <meta name="description" content="A new Flutter project.">
+  <meta name="description" content="OpenWearables app.">
 
   <!-- iOS meta tags -->
   <meta name="mobile-web-app-capable" content="yes">
   <meta name="apple-mobile-web-app-status-bar-style" content="black">
-  <meta name="apple-mobile-web-app-title" content="open_wearable">
+  <meta name="apple-mobile-web-app-title" content="OpenWearables">
 
-  <title>OpenWearable | App</title>
+  <title>OpenWearables | App</title>
 </head>
 <body>
   <script>
diff --git a/open_wearable/web/manifest.json b/open_wearable/web/manifest.json
index 12192319..37db8993 100644
--- a/open_wearable/web/manifest.json
+++ b/open_wearable/web/manifest.json
@@ -1,11 +1,11 @@
 {
-     "name": "OpenWearable",
-     "short_name": "OpenWearable",
+     "name": "OpenWearables",
+     "short_name": "OpenWearables",
      "start_url": ".",
      "display": "standalone",
      "background_color": "#0175C2",
      "theme_color": "#0175C2",
-     "description": "A new Flutter project.",
+     "description": "OpenWearables app.",
      "orientation": "portrait-primary",
      "prefer_related_applications": false,
      "icons": [
diff --git a/open_wearable/windows/runner/Runner.rc b/open_wearable/windows/runner/Runner.rc
index 5da345e6..8c4663b0 100644
--- a/open_wearable/windows/runner/Runner.rc
+++ b/open_wearable/windows/runner/Runner.rc
@@ -90,12 +90,12 @@ BEGIN
         BLOCK "040904e4"
         BEGIN
             VALUE "CompanyName", "com.example" "\0"
-            VALUE "FileDescription", "open_wearable" "\0"
+            VALUE "FileDescription", "OpenWearables" "\0"
             VALUE "FileVersion", VERSION_AS_STRING "\0"
-            VALUE "InternalName", "open_wearable" "\0"
+            VALUE "InternalName", "OpenWearables" "\0"
             VALUE "LegalCopyright", "Copyright (C) 2025 com.example. All rights reserved." "\0"
             VALUE "OriginalFilename", "open_wearable.exe" "\0"
-            VALUE "ProductName", "open_wearable" "\0"
+            VALUE "ProductName", "OpenWearables" "\0"
             VALUE "ProductVersion", VERSION_AS_STRING "\0"
         END
     END
diff --git a/open_wearable/windows/runner/main.cpp b/open_wearable/windows/runner/main.cpp
index 8cec8e1d..d932613b 100644
--- a/open_wearable/windows/runner/main.cpp
+++ b/open_wearable/windows/runner/main.cpp
@@ -27,7 +27,7 @@ int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
   FlutterWindow window(project);
   Win32Window::Point origin(10, 10);
   Win32Window::Size size(1280, 720);
-  if (!window.Create(L"OpenWearable", origin, size)) {
+  if (!window.Create(L"OpenWearables", origin, size)) {
     return EXIT_FAILURE;
   }
   window.SetQuitOnClose(true);