expo-dev-menu 55.0.8 → 55.0.10

package/CHANGELOG.md

@@ -10,6 +10,14 @@
 
 ### 💡 Others
 
+## 55.0.10 — 2026-02-26
+
+_This version does not introduce any user-facing changes._
+
+## 55.0.9 — 2026-02-25
+
+_This version does not introduce any user-facing changes._
+
 ## 55.0.8 — 2026-02-25
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -12,7 +12,7 @@ apply plugin: 'expo-module-gradle-plugin'
 apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
 group = 'host.exp.exponent'
-version = '55.0.8'
+version = '55.0.10'
 
 def hasDevLauncher = findProject(":expo-dev-launcher") != null
 def configureInRelease = findProperty("expo.devmenu.configureInRelease") == "true"
@@ -29,7 +29,7 @@ android {
 
   defaultConfig {
     versionCode 10
-    versionName '55.0.8'
+    versionName '55.0.10'
   }
 
   buildTypes {

package/android/src/debug/java/expo/modules/devmenu/DevMenuFragment.kt

@@ -180,10 +180,7 @@ class DevMenuFragment(
               DevMenuBottomSheet(viewModel.state, viewModel::onAction)
               MovableFloatingActionButton(
                 state = viewModel.state,
-                onRefreshPress = {
-                  viewModel.onAction(DevMenuAction.Reload)
-                },
-                onOpenMenuPress = {
+                onPress = {
                   viewModel.onAction(DevMenuAction.Open)
                 }
               )

package/android/src/debug/java/expo/modules/devmenu/DevMenuPreferences.kt

@@ -3,7 +3,6 @@ package expo.modules.devmenu
 import android.app.Application
 import android.content.Context.MODE_PRIVATE
 import android.content.SharedPreferences
-import expo.modules.core.utilities.VRUtilities
 import expo.modules.devmenu.helpers.preferences
 
 private const val DEV_SETTINGS_PREFERENCES = "expo.modules.devmenu.sharedpreferences"
@@ -90,5 +89,5 @@ class DevMenuDefaultPreferences(
     by preferences(sharedPreferences, false)
 
   override var showFab: Boolean
-    by preferences(sharedPreferences, VRUtilities.isQuest())
+    by preferences(sharedPreferences, true)
 }

package/android/src/debug/java/expo/modules/devmenu/compose/ui/ToolsSection.kt

@@ -126,7 +126,7 @@ fun ToolsSection(
           },
           content = {
             NewText(
-              text = "Show dev menu button"
+              text = "Tools button"
             )
           },
           rightComponent = {

package/android/src/debug/java/expo/modules/devmenu/fab/FabState.kt

@@ -0,0 +1,109 @@
+package expo.modules.devmenu.fab
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.VectorConverter
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.core.content.edit
+import kotlinx.coroutines.delay
+
+private const val IdleTimeoutMs = 5_000L
+private const val FAB_PREFS = "expo.modules.devmenu.sharedpreferences"
+private const val FAB_POSITION_X = "fabPositionX"
+private const val FAB_POSITION_Y = "fabPositionY"
+private const val FAB_POSITION_UNSET = -1f
+
+data class FabBounds(
+  val screen: Offset,
+  val safe: Offset,
+  val safeMinY: Float,
+  val drag: Offset,
+  val halfFab: Offset
+)
+
+class FabState(
+  initialOffset: Offset,
+  val bounds: FabBounds,
+  val prefs: SharedPreferences
+) {
+  val animatedOffset = Animatable(initialOffset, Offset.VectorConverter)
+  var isPressed by mutableStateOf(false)
+  var isDragging by mutableStateOf(false)
+  var isIdle by mutableStateOf(false)
+  var isOffScreen by mutableStateOf(false)
+  var restingOffset by mutableStateOf(initialOffset)
+  var lastInteractionTime by mutableLongStateOf(System.currentTimeMillis())
+
+  fun onInteraction() {
+    lastInteractionTime = System.currentTimeMillis()
+  }
+
+  fun savePosition(offset: Offset) {
+    val safeWidth = bounds.safe.x
+    val safeHeight = bounds.safe.y - bounds.safeMinY
+
+    // Store position as 0–1 ratios within the safe area so it survives screen size changes
+    val normalizedX = if (safeWidth > 0f) offset.x / safeWidth else 0f
+    val normalizedY = if (safeHeight > 0f) (offset.y - bounds.safeMinY) / safeHeight else 0f
+
+    prefs.edit {
+      putFloat(FAB_POSITION_X, normalizedX)
+      putFloat(FAB_POSITION_Y, normalizedY)
+    }
+  }
+}
+
+@Composable
+fun rememberFabState(screenBounds: Offset, totalFabSizePx: Offset): FabState {
+  val density = LocalDensity.current
+  val systemBarInsets = WindowInsets.systemBars
+  val safeInsetTop = with(density) { systemBarInsets.getTop(this).toFloat() }
+  val safeInsetBottom = with(density) { systemBarInsets.getBottom(this).toFloat() }
+  val halfFab = Offset(totalFabSizePx.x / 2f, totalFabSizePx.y / 2f)
+
+  val fabBounds = FabBounds(
+    screen = screenBounds,
+    safe = Offset(screenBounds.x, screenBounds.y - safeInsetBottom),
+    safeMinY = safeInsetTop,
+    drag = Offset(screenBounds.x + halfFab.x, screenBounds.y + halfFab.y),
+    halfFab = halfFab
+  )
+
+  val context = LocalContext.current
+  val prefs = remember { context.getSharedPreferences(FAB_PREFS, Context.MODE_PRIVATE) }
+
+  val initialOffset = remember(fabBounds.safe, fabBounds.safeMinY) {
+    val savedX = prefs.getFloat(FAB_POSITION_X, FAB_POSITION_UNSET)
+    val savedY = prefs.getFloat(FAB_POSITION_Y, FAB_POSITION_UNSET)
+    if (savedX != FAB_POSITION_UNSET && savedY != FAB_POSITION_UNSET) {
+      Offset(
+        x = (savedX * fabBounds.safe.x).coerceIn(0f, fabBounds.safe.x),
+        y = (savedY * (fabBounds.safe.y - fabBounds.safeMinY) + fabBounds.safeMinY).coerceIn(fabBounds.safeMinY, fabBounds.safe.y)
+      )
+    } else {
+      Offset(fabBounds.safe.x, fabBounds.safeMinY)
+    }
+  }
+
+  val state = remember { FabState(initialOffset, fabBounds, prefs) }
+
+  LaunchedEffect(state.lastInteractionTime) {
+    state.isIdle = false
+    delay(IdleTimeoutMs)
+    state.isIdle = true
+  }
+
+  return state
+}

package/android/src/debug/java/expo/modules/devmenu/fab/FabUtils.kt

@@ -1,7 +1,5 @@
 package expo.modules.devmenu.fab
 
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.PressInteraction
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.mutableStateOf
@@ -18,7 +16,8 @@ internal fun calculateTargetPosition(
   currentPosition: Offset,
   velocity: PointF,
   bounds: Offset,
-  totalFabWidth: Float
+  totalFabWidth: Float,
+  minY: Float = 0f
 ): Offset {
   // Simulate the bubble keeping the movement momentum
   // I've found that these values feel good (assume that the bubble keeps the momentum for ~100ms)
@@ -32,7 +31,7 @@ internal fun calculateTargetPosition(
   }
   val targetY = currentPosition.y + momentumOffsetY
   val newOffset = Offset(targetX, targetY)
-    .coerceIn(maxX = bounds.x, maxY = bounds.y)
+    .coerceIn(minY = minY, maxX = bounds.x, maxY = bounds.y)
   return newOffset
 }
 
@@ -60,8 +59,3 @@ internal fun <T> rememberPrevious(current: T): T? {
 
   return previousRef.value
 }
-
-internal suspend fun MutableInteractionSource.emitRelease(pressPosition: Offset) {
-  val pressInteraction = PressInteraction.Press(pressPosition)
-  this.emit(PressInteraction.Release(pressInteraction))
-}

package/android/src/debug/java/expo/modules/devmenu/fab/FloatingActionButtonContent.kt

@@ -1,148 +1,141 @@
 package expo.modules.devmenu.fab
 
-import android.annotation.SuppressLint
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.spring
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.draw.drawWithContent
 import androidx.compose.ui.draw.scale
 import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.nativeCanvas
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import com.composeunstyled.Icon
+import com.composeunstyled.Text
 import expo.modules.devmenu.R
-import expo.modules.devmenu.compose.newtheme.NewAppTheme
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+
+private val FabBlue = Color(0xFF007AFF)
 
-@SuppressLint("UnusedBoxWithConstraintsScope")
 @Composable
 fun FloatingActionButtonContent(
   modifier: Modifier = Modifier,
-  interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
-  onRefreshPress: () -> Unit = {},
-  onEllipsisPress: () -> Unit = {}
+  isPressed: Boolean = false,
+  isDragging: Boolean = false,
+  isIdle: Boolean = false
 ) {
-  val pillShape = RoundedCornerShape(percent = 50)
-  val horizontalPadding = 14.dp
-  val verticalPadding = 16.dp
-  val animatedRotation = remember { Animatable(0f) }
-  val animatedScale = remember { Animatable(1f) }
-  val scope = rememberCoroutineScope()
+  val scale by animateFloatAsState(
+    targetValue = if (isPressed && !isDragging) 0.9f else 1f,
+    label = "pressScale"
+  )
+
+  val idleAlpha by animateFloatAsState(
+    targetValue = if (isIdle) 0.5f else 1f,
+    label = "idleAlpha"
+  )
+
+  val idleSaturation by animateFloatAsState(
+    targetValue = if (isIdle) 0f else 1f,
+    label = "idleSaturation"
+  )
+
+  var showLabel by remember { mutableStateOf(true) }
 
-  BoxWithConstraints(
+  LaunchedEffect(Unit) {
+    delay(10_000)
+    showLabel = false
+  }
+
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally,
     modifier = modifier
-      .shadow(6.dp, pillShape)
-      .border(
-        width = 1.dp,
-        color = NewAppTheme.colors.border.default,
-        shape = pillShape
-      )
-      .background(
-        color = NewAppTheme.colors.background.default,
-        shape = pillShape
-      )
-      .clip(pillShape)
+      .scale(scale)
+      .graphicsLayer {
+        alpha = idleAlpha
+      }
+      .drawWithContent {
+        val colorMatrix = android.graphics.ColorMatrix()
+        colorMatrix.setSaturation(idleSaturation)
+        val paint = android.graphics.Paint().apply {
+          colorFilter = android.graphics.ColorMatrixColorFilter(colorMatrix)
+        }
+        drawContext.canvas.nativeCanvas.saveLayer(null, paint)
+        drawContent()
+        drawContext.canvas.nativeCanvas.restore()
+      }
   ) {
-    val iconSize = maxWidth - (horizontalPadding * 2)
-
-    Column(
-      verticalArrangement = Arrangement.SpaceBetween,
-      horizontalAlignment = Alignment.CenterHorizontally,
-      modifier = modifier
-        .border(
-          width = 1.dp,
-          color = NewAppTheme.colors.border.default,
-          shape = pillShape
+    Box(
+      contentAlignment = Alignment.Center,
+      modifier = Modifier
+        .shadow(
+          elevation = 8.dp,
+          shape = CircleShape,
+          ambientColor = Color.Black.copy(alpha = 0.4f),
+          spotColor = Color.Black.copy(alpha = 0.4f)
         )
-        .fillMaxSize()
-        .padding(horizontal = horizontalPadding, vertical = verticalPadding)
+        .size(52.dp)
+        .border(4.dp, FabBlue.copy(alpha = 0.3f), CircleShape)
+        .padding(4.dp)
+        .background(FabBlue, CircleShape)
     ) {
       Icon(
-        painter = painterResource(R.drawable.refresh_round_icon),
-        contentDescription = "Refresh",
-        tint = NewAppTheme.colors.icon.tertiary,
-        modifier = Modifier
-          .size(iconSize)
-          .rotate(animatedRotation.value)
-          .clickable(
-            interactionSource = interactionSource,
-            indication = null,
-            onClick = {
-              scope.launch {
-                animatedRotation.animateTo(
-                  targetValue = 360f,
-                  animationSpec = spring(
-                    dampingRatio = Spring.DampingRatioLowBouncy,
-                    stiffness = Spring.StiffnessVeryLow,
-                    visibilityThreshold = 5f
-                  )
-                )
-                onRefreshPress()
-                animatedRotation.snapTo(0f)
-              }
-            }
-          )
+        painter = painterResource(R.drawable.gear_fill),
+        contentDescription = "Tools",
+        tint = Color.White,
+        modifier = Modifier.size(26.dp)
       )
+    }
 
-      Icon(
-        painter = painterResource(R.drawable.ellipsis_horizontal),
-        contentDescription = "Open Dev Menu",
-        tint = NewAppTheme.colors.icon.tertiary,
+    AnimatedVisibility(
+      visible = showLabel,
+      exit = fadeOut() + scaleOut()
+    ) {
+      Box(
         modifier = Modifier
-          .size(iconSize)
-          .scale(animatedScale.value)
-          .clickable(
-            interactionSource = interactionSource,
-            // TODO @behenate: Figure out how to use ripple instead of scale animation with an interaction source shared by both buttons
-            indication = null,
-            onClick = {
-              onEllipsisPress()
-              scope.launch {
-                animatedScale.snapTo(0.9f)
-                animatedScale.animateTo(
-                  targetValue = 1f,
-                  animationSpec = spring(
-                    dampingRatio = Spring.DampingRatioMediumBouncy,
-                    stiffness = Spring.StiffnessLow
-                  )
-                )
-              }
-            }
-          )
-      )
+          .padding(top = 6.dp)
+          .shadow(4.dp, RoundedCornerShape(percent = 50))
+          .background(Color.White, RoundedCornerShape(percent = 50))
+          .padding(horizontal = 10.dp, vertical = 4.dp)
+      ) {
+        Text(
+          text = "Tools",
+          color = Color.Black,
+          fontSize = 11.sp,
+          fontWeight = FontWeight.SemiBold
+        )
+      }
     }
   }
 }
 
 @Preview(showBackground = true)
 @Composable
-fun VerticalActionPillPreview() {
-  // You would typically wrap this in your app's theme.
-  // Using a basic Column for positioning in the preview.
+fun FloatingActionButtonContentPreview() {
   Column(
-    modifier = Modifier
-      .padding(32.dp)
-      .background(NewAppTheme.colors.border.default),
+    modifier = Modifier.padding(32.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    FloatingActionButtonContent(modifier = Modifier.size(46.dp, 92.dp))
+    FloatingActionButtonContent()
   }
 }

package/android/src/debug/java/expo/modules/devmenu/fab/MovableFloatingActionButton.kt

@@ -2,16 +2,13 @@ package expo.modules.devmenu.fab
 
 import android.annotation.SuppressLint
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.AnimationVector2D
 import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.VectorConverter
 import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.drag
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.fillMaxSize
@@ -34,12 +31,10 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 
-private val FabDefaultSize = DpSize(48.dp, 92.dp)
+private val FabDefaultSize = DpSize(72.dp, 94.dp)
 private val Margin = 16.dp
 private const val ClickDragTolerance = 40f
 
-private typealias AnimatableOffset = Animatable<Offset, AnimationVector2D>
-
 /**
  * A floating action button that can be dragged across the screen and springs to the
  * nearest horizontal edge when released. A tap triggers the onClick action.
@@ -51,8 +46,7 @@ fun MovableFloatingActionButton(
   modifier: Modifier = Modifier,
   fabSize: DpSize = FabDefaultSize,
   margin: Dp = Margin,
-  onRefreshPress: () -> Unit = {},
-  onOpenMenuPress: () -> Unit = {}
+  onPress: () -> Unit = {}
 ) {
   BoxWithConstraints(modifier = modifier.fillMaxSize()) {
     val totalFabSize = DpSize(fabSize.width + margin * 2, fabSize.height + margin * 2)
@@ -63,6 +57,8 @@ fun MovableFloatingActionButton(
       x = constraints.maxWidth - totalFabSizePx.x,
       y = constraints.maxHeight - totalFabSizePx.y
     )
+
+    val fab = rememberFabState(bounds, totalFabSizePx)
     val isFabDisplayable = state.showFab &&
       !state.isInPictureInPictureMode &&
       bounds.x >= 0f &&
@@ -70,27 +66,48 @@ fun MovableFloatingActionButton(
 
     val previousBounds = rememberPrevious(bounds)
     val velocityTracker = remember { ExpoVelocityTracker() }
-    val defaultOffset = bounds.copy(y = bounds.y * 0.75f)
-    val animatedOffset = remember { Animatable(defaultOffset, Offset.VectorConverter) }
-    val pillInteractionSource = remember { MutableInteractionSource() }
+
+    LaunchedEffect(state.isOpen) {
+      if (state.isOpen) {
+        fab.restingOffset = fab.animatedOffset.value
+        val isOnLeftSide = fab.animatedOffset.value.x < fab.bounds.safe.x / 2f
+        val offScreenX = if (isOnLeftSide) -totalFabSizePx.x else constraints.maxWidth.toFloat()
+        fab.animatedOffset.animateTo(
+          targetValue = Offset(offScreenX, fab.animatedOffset.value.y),
+          animationSpec = tween(durationMillis = 500)
+        )
+        fab.isOffScreen = true
+      } else if (fab.isOffScreen) {
+        fab.animatedOffset.animateTo(
+          targetValue = fab.restingOffset,
+          animationSpec = spring(
+            dampingRatio = 0.6f,
+            stiffness = Spring.StiffnessLow
+          )
+        )
+        fab.isOffScreen = false
+        fab.onInteraction()
+      }
+    }
 
     LaunchedEffect(bounds.x, bounds.y, isFabDisplayable) {
       if (!isFabDisplayable) {
         return@LaunchedEffect
       }
       previousBounds?.let {
-        val oldX = animatedOffset.value.x
-        val oldY = animatedOffset.value.y
-        val newX = (oldX / previousBounds.x) * bounds.x
-        val newY = (oldY / previousBounds.y) * bounds.y
+        val oldX = fab.animatedOffset.value.x
+        val oldY = fab.animatedOffset.value.y
+        val newX = (oldX / previousBounds.x) * fab.bounds.safe.x
+        val newY = (oldY / previousBounds.y) * fab.bounds.safe.y
         val newTarget = calculateTargetPosition(
           currentPosition = Offset(newX, newY),
           velocity = ExpoVelocityTracker.PointF(0f, 0f),
-          bounds = bounds,
-          totalFabWidth = totalFabSizePx.x
+          bounds = fab.bounds.safe,
+          totalFabWidth = totalFabSizePx.x,
+          minY = fab.bounds.safeMinY
         )
 
-        animatedOffset.snapTo(newTarget)
+        fab.animatedOffset.snapTo(newTarget)
       }
     }
 
@@ -101,7 +118,7 @@ fun MovableFloatingActionButton(
     ) {
       Box(
         modifier = Modifier
-          .offset { animatedOffset.value.toIntOffset() }
+          .offset { fab.animatedOffset.value.toIntOffset() }
           .size(totalFabSize)
           .padding(margin)
           .pointerInput(bounds.x, bounds.y) {
@@ -110,33 +127,40 @@ fun MovableFloatingActionButton(
                 awaitPointerEventScope {
                   val firstDown = awaitFirstDown(requireUnconsumed = false)
                   val pointerId = firstDown.id
+                  fab.isPressed = true
+                  fab.isDragging = false
+                  fab.onInteraction()
 
                   launch {
-                    animatedOffset.stop()
+                    fab.animatedOffset.stop()
                   }
 
                   var dragDistance = 0f
-                  var dragOffset = animatedOffset.value
+                  var dragOffset = fab.animatedOffset.value
 
                   drag(pointerId) { change ->
                     dragOffset = (dragOffset + change.positionChange())
-                      .coerceIn(maxX = bounds.x, maxY = bounds.y)
+                      .coerceIn(minX = -fab.bounds.halfFab.x, maxX = fab.bounds.drag.x, minY = -fab.bounds.halfFab.y, maxY = fab.bounds.drag.y)
                     dragDistance += change.positionChange().getDistance()
                     velocityTracker.registerPosition(dragOffset.x, dragOffset.y)
 
                     if (dragDistance > ClickDragTolerance) {
+                      fab.isDragging = true
                       launch {
-                        animatedOffset.animateTo(dragOffset)
+                        fab.animatedOffset.animateTo(dragOffset)
                       }
                     }
                   }
+
+                  fab.isPressed = false
+                  fab.isDragging = false
+                  fab.onInteraction()
+
                   if (dragDistance < ClickDragTolerance) {
                     velocityTracker.clear()
-                    launch {
-                      pillInteractionSource.emitRelease(firstDown.position)
-                    }
+                    onPress()
                   } else {
-                    handleRelease(animatedOffset, velocityTracker, totalFabSizePx, bounds)
+                    handleRelease(fab, velocityTracker, totalFabSizePx)
                   }
                 }
               }
@@ -144,9 +168,9 @@ fun MovableFloatingActionButton(
           }
       ) {
         FloatingActionButtonContent(
-          interactionSource = pillInteractionSource,
-          onRefreshPress = onRefreshPress,
-          onEllipsisPress = onOpenMenuPress,
+          isPressed = fab.isPressed,
+          isDragging = fab.isDragging,
+          isIdle = fab.isIdle,
           modifier = Modifier.fillMaxSize()
         )
       }
@@ -158,17 +182,16 @@ fun MovableFloatingActionButton(
  * Handles the release of the FAB, calculating momentum and animating it to the nearest edge.
  */
 private fun CoroutineScope.handleRelease(
-  animatedOffset: AnimatableOffset,
+  fab: FabState,
   velocityTracker: ExpoVelocityTracker,
-  totalFabSizePx: Offset,
-  bounds: Offset
+  totalFabSizePx: Offset
 ) {
   val velocity = velocityTracker.calculateVelocity()
-  val newOffset = calculateTargetPosition(animatedOffset.value, velocity, bounds, totalFabSizePx.x)
+  val newOffset = calculateTargetPosition(fab.animatedOffset.value, velocity, fab.bounds.safe, totalFabSizePx.x, fab.bounds.safeMinY)
 
   velocityTracker.clear()
   launch {
-    animatedOffset.animateTo(
+    fab.animatedOffset.animateTo(
       targetValue = newOffset,
       animationSpec = spring(
         dampingRatio = 0.65f,
@@ -176,5 +199,6 @@ private fun CoroutineScope.handleRelease(
       ),
       initialVelocity = Offset(velocity.x, velocity.y)
     )
+    fab.savePosition(newOffset)
   }
 }

package/android/src/debug/res/drawable/gear_fill.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:fillColor="#FFFFFF"
+      android:pathData="M19.14,12.94c0.04,-0.3 0.06,-0.61 0.06,-0.94c0,-0.32 -0.02,-0.64 -0.07,-0.94l2.03,-1.58c0.18,-0.14 0.23,-0.41 0.12,-0.61l-1.92,-3.32c-0.12,-0.22 -0.37,-0.29 -0.59,-0.22l-2.39,0.96c-0.5,-0.38 -1.03,-0.7 -1.62,-0.94L14.4,2.81c-0.04,-0.24 -0.24,-0.41 -0.48,-0.41h-3.84c-0.24,0 -0.43,0.17 -0.47,0.41L9.25,5.35C8.66,5.59 8.12,5.92 7.63,6.29L5.24,5.33c-0.22,-0.08 -0.47,0 -0.59,0.22L2.74,8.87C2.62,9.08 2.66,9.34 2.86,9.48l2.03,1.58C4.84,11.36 4.8,11.69 4.8,12s0.02,0.64 0.07,0.94l-2.03,1.58c-0.18,0.14 -0.23,0.41 -0.12,0.61l1.92,3.32c0.12,0.22 0.37,0.29 0.59,0.22l2.39,-0.96c0.5,0.38 1.03,0.7 1.62,0.94l0.36,2.54c0.05,0.24 0.24,0.41 0.48,0.41h3.84c0.24,0 0.44,-0.17 0.47,-0.41l0.36,-2.54c0.59,-0.24 1.13,-0.56 1.62,-0.94l2.39,0.96c0.22,0.08 0.47,0 0.59,-0.22l1.92,-3.32c0.12,-0.22 0.07,-0.47 -0.12,-0.61L19.14,12.94zM12,15.6c-1.98,0 -3.6,-1.62 -3.6,-3.6s1.62,-3.6 3.6,-3.6s3.6,1.62 3.6,3.6S13.98,15.6 12,15.6z"/>
+</vector>

package/ios/DevMenuManager.swift

@@ -547,9 +547,9 @@ open class DevMenuManager: NSObject {
     fabWindow = DevMenuFABWindow(manager: self, windowScene: windowScene)
   }
 
-  public func updateFABVisibility(menuDismissing: Bool = false) {
+  public func updateFABVisibility() {
     DispatchQueue.main.async { [weak self] in
-      guard let self = self else { return }
+      guard let self else { return }
 
       if self.fabWindow == nil {
         if let windowScene = UIApplication.shared.connectedScenes
@@ -559,7 +559,7 @@ open class DevMenuManager: NSObject {
       }
 
       let shouldShow = DevMenuPreferences.showFloatingActionButton
-        && (menuDismissing || !self.isVisible)
+        && !self.isVisible
         && self.currentBridge != nil
         && !self.isNavigatingHome
         && DevMenuPreferences.isOnboardingFinished
@@ -567,7 +567,7 @@ open class DevMenuManager: NSObject {
     }
   }
   #else
-  public func updateFABVisibility(menuDismissing: Bool = false) {
+  public func updateFABVisibility() {
     // FAB not available on macOS/tvOS
   }
   #endif

package/ios/DevMenuWindow-default.swift

@@ -103,12 +103,11 @@ class DevMenuWindow: UIWindow, PresentationControllerDelegate {
       self.backgroundColor = .clear
     }
 
-    DevMenuManager.shared.updateFABVisibility(menuDismissing: true)
-
     devMenuViewController.dismiss(animated: true) {
       self.isDismissing = false
       self.isHidden = true
       self.backgroundColor = UIColor(white: 0, alpha: 0.4)
+      DevMenuManager.shared.updateFABVisibility()
       completion?()
     }
   }

package/ios/DevMenuWindow-macOS.swift

@@ -100,7 +100,7 @@ class DevMenuWindow: NSObject, AnyObject {
       ctx.duration = 0.3
       overlay.animator().alphaValue = 0.0
     }, completionHandler: { [weak self] in
-      guard let self = self else { return }
+      guard let self else { return }
       overlay.removeFromSuperview()
       self.overlayView = nil
       self.hostingView = nil

package/ios/FAB/DevMenuFABView.swift

@@ -6,8 +6,8 @@ import SwiftUI
 
 enum FABConstants {
   static let iconSize: CGFloat = 44
-  static let margin: CGFloat = 16
-  static let verticalPadding: CGFloat = 20
+  static let margin: CGFloat = 10
+  static let verticalPadding: CGFloat = 0
   static let dragThreshold: CGFloat = 10
   static let momentumFactor: CGFloat = 0.35
   static let labelDismissDelay: TimeInterval = 10
@@ -52,7 +52,7 @@ struct FabPill: View {
         }
 
       if showLabel {
-        Text("Dev menu")
+        Text("Tools")
           .font(.system(size: 11, weight: .medium))
           .foregroundStyle(.secondary)
           .fixedSize()
@@ -77,15 +77,6 @@ struct FabPill: View {
     }
   }
 
-  @ViewBuilder
-  private var actionButton: some View {
-    if #available(iOS 26.0, *) {
-      liquidGlassButton
-    } else {
-      classicButton
-    }
-  }
-
   private func startIdleTimer() {
     idleTask?.cancel()
     idleTask = Task {
@@ -99,22 +90,7 @@ struct FabPill: View {
     }
   }
 
-  @available(iOS 26.0, *)
-  private var liquidGlassButton: some View {
-    Image(systemName: "gearshape.fill")
-      .resizable()
-      .frame(width: FABConstants.imageSize, height: FABConstants.imageSize)
-      .foregroundStyle(.white)
-      .frame(width: FABConstants.iconSize, height: FABConstants.iconSize)
-      .background(
-        Circle()
-          .frame(width: FABConstants.iconSize + 10, height: FABConstants.iconSize + 10)
-          .glassEffect(.clear, in: Circle())
-      )
-      .shadow(color: .black.opacity(0.4), radius: 8, x: 0, y: 4)
-  }
-
-  private var classicButton: some View {
+  private var actionButton: some View {
     Image(systemName: "gearshape.fill")
       .resizable()
       .frame(width: FABConstants.imageSize, height: FABConstants.imageSize)
@@ -136,15 +112,41 @@ struct DevMenuFABView: View {
 
   private let fabSize = CGSize(width: 72, height: FABConstants.iconSize + 50)
 
+  // UserDefaults keys for persisting position
+  private static let positionXKey = "DevMenuFAB.positionX"
+  private static let positionYKey = "DevMenuFAB.positionY"
+  private static let hasStoredPositionKey = "DevMenuFAB.hasStoredPosition"
+
+  private static func loadStoredPosition() -> CGPoint? {
+    guard UserDefaults.standard.bool(forKey: hasStoredPositionKey) else { return nil }
+    let x = UserDefaults.standard.double(forKey: positionXKey)
+    let y = UserDefaults.standard.double(forKey: positionYKey)
+    return CGPoint(x: x, y: y)
+  }
+
+  private static func savePosition(_ position: CGPoint) {
+    UserDefaults.standard.set(position.x, forKey: positionXKey)
+    UserDefaults.standard.set(position.y, forKey: positionYKey)
+    UserDefaults.standard.set(true, forKey: hasStoredPositionKey)
+  }
+
   @State private var position: CGPoint = .zero
-  @State private var targetPosition: CGPoint = .zero
   @State private var isDragging = false
   @State private var isPressed = false
   @State private var dragStartPosition: CGPoint = .zero
 
+  // Get safe area from window since .ignoresSafeArea() may zero out geometry values
+  private var windowSafeArea: UIEdgeInsets {
+    guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+          let window = windowScene.windows.first else {
+      return .zero
+    }
+    return window.safeAreaInsets
+  }
+
   private let dragSpring: Animation = .spring(
-    response: 0.35,
-    dampingFraction: 0.35,
+    response: 0.25,
+    dampingFraction: 0.85,
     blendDuration: 0
   )
 
@@ -154,14 +156,34 @@ struct DevMenuFABView: View {
 
   var body: some View {
     GeometryReader { geometry in
-      let safeArea = geometry.safeAreaInsets
+      // Use window safe area - geometry values may be incorrect initially or due to .ignoresSafeArea()
+      let safeArea = EdgeInsets(
+        top: windowSafeArea.top,
+        leading: windowSafeArea.left,
+        bottom: windowSafeArea.bottom,
+        trailing: windowSafeArea.right
+      )
 
       FabPill(isPressed: $isPressed, isDragging: $isDragging)
         .frame(width: fabSize.width, height: fabSize.height)
         .position(x: currentFrame.midX, y: currentFrame.midY)
         .gesture(dragGesture(bounds: geometry.size, safeArea: safeArea))
         .onAppear {
-          let initialPos = defaultPosition(bounds: geometry.size, safeArea: safeArea)
+          let initialPos: CGPoint
+          if let storedPos = Self.loadStoredPosition() {
+            let margin = FABConstants.margin
+            let minX = margin / 2
+            let maxX = geometry.size.width - fabSize.width - margin / 2
+            let minY = safeArea.top + FABConstants.verticalPadding
+            let maxY = geometry.size.height - fabSize.height - safeArea.bottom - FABConstants.verticalPadding
+
+            initialPos = CGPoint(
+              x: storedPos.x.clamped(to: minX...maxX),
+              y: storedPos.y.clamped(to: minY...maxY)
+            )
+          } else {
+            initialPos = defaultPosition(bounds: geometry.size, safeArea: safeArea)
+          }
           position = initialPos
           onFrameChange(CGRect(origin: initialPos, size: fabSize))
         }
@@ -192,19 +214,10 @@ struct DevMenuFABView: View {
           dragStartPosition = position
         }
         if isDragging {
-          let margin = FABConstants.margin
-          let minX = margin
-          let maxX = bounds.width - fabSize.width - margin
-          let minY = margin + safeArea.top + FABConstants.verticalPadding
-          let maxY = bounds.height - fabSize.height - margin - safeArea.bottom - FABConstants.verticalPadding
-
           let rawX = dragStartPosition.x + value.translation.width
           let rawY = dragStartPosition.y + value.translation.height
 
-          position = CGPoint(
-            x: rawX.clamped(to: minX...maxX),
-            y: rawY.clamped(to: minY...maxY)
-          )
+          position = CGPoint(x: rawX, y: rawY)
           onFrameChange(currentFrame)
         }
       }
@@ -231,6 +244,7 @@ struct DevMenuFABView: View {
           DispatchQueue.main.async {
             isDragging = false
             position = newPos
+            Self.savePosition(newPos)
             onFrameChange(CGRect(origin: newPos, size: fabSize))
           }
         }
@@ -239,8 +253,8 @@ struct DevMenuFABView: View {
 
   private func defaultPosition(bounds: CGSize, safeArea: EdgeInsets) -> CGPoint {
     CGPoint(
-      x: bounds.width - fabSize.width - FABConstants.margin,
-      y: bounds.height * 0.25
+      x: bounds.width - fabSize.width - FABConstants.margin / 2,
+      y: safeArea.top + FABConstants.verticalPadding
     )
   }
 
@@ -251,16 +265,17 @@ struct DevMenuFABView: View {
     safeArea: EdgeInsets
   ) -> CGPoint {
     let margin = FABConstants.margin
+    let edgeMargin = margin / 2  // Closer to screen edge when snapped
     let momentumX = velocity.x * FABConstants.momentumFactor
     let momentumY = velocity.y * FABConstants.momentumFactor
 
     let estimatedCenterX = point.x + self.fabSize.width / 2 + momentumX
     let targetX: CGFloat = estimatedCenterX < bounds.width / 2
-      ? margin
-    : bounds.width - self.fabSize.width - margin
+      ? edgeMargin
+    : bounds.width - self.fabSize.width - edgeMargin
 
-    let minY = margin + safeArea.top + FABConstants.verticalPadding
-    let maxY = bounds.height - self.fabSize.height - margin - safeArea.bottom - FABConstants.verticalPadding
+    let minY = safeArea.top + FABConstants.verticalPadding
+    let maxY = bounds.height - self.fabSize.height - safeArea.bottom - FABConstants.verticalPadding
     let targetY = (point.y + momentumY).clamped(to: minY...maxY)
 
     return CGPoint(x: targetX, y: targetY)

package/ios/FAB/DevMenuFABWindow.swift

@@ -10,6 +10,8 @@ class DevMenuFABWindow: UIWindow {
   private weak var manager: DevMenuManager?
   private var hostingController: UIHostingController<DevMenuFABView>?
   var fabFrame: CGRect = .zero
+  private var currentAnimator: UIViewPropertyAnimator?
+  private var targetVisibility: Bool?
 
   init(manager: DevMenuManager, windowScene: UIWindowScene) {
     self.manager = manager
@@ -51,44 +53,48 @@ class DevMenuFABWindow: UIWindow {
   }
 
   func setVisible(_ visible: Bool, animated: Bool = true) {
+    // Skip if already animating to the same state
+    if targetVisibility == visible {
+      return
+    }
+
+    // Cancel any in-progress animation and reset to clean state
+    if currentAnimator != nil {
+      currentAnimator?.stopAnimation(true)
+      currentAnimator = nil
+      transform = .identity
+    }
+
+    targetVisibility = visible
+
     if visible {
       isHidden = false
-      if animated {
-        alpha = 0
-        transform = edgeTranslation
-        UIView.animate(
-          withDuration: 0.5,
-          delay: 0,
-          usingSpringWithDamping: 0.6,
-          initialSpringVelocity: 0.8,
-          options: .curveEaseOut
-        ) {
-          self.alpha = 1
-          self.transform = .identity
-        }
-      } else {
-        alpha = 1
-        transform = .identity
+      alpha = 0
+      transform = edgeTranslation
+
+      let animator = UIViewPropertyAnimator(duration: animated ? 0.5 : 0, dampingRatio: 0.6) {
+        self.alpha = 1
+        self.transform = .identity
       }
+      animator.addCompletion { [weak self] _ in
+        self?.targetVisibility = nil
+      }
+      currentAnimator = animator
+      animator.startAnimation()
     } else {
-      if animated {
-        UIView.animate(
-          withDuration: 0.4,
-          delay: 0,
-          usingSpringWithDamping: 0.6,
-          initialSpringVelocity: 0.8,
-          options: .curveEaseIn
-        ) {
-          self.alpha = 0
-          self.transform = self.edgeTranslation
-        } completion: { _ in
-          self.isHidden = true
-          self.transform = .identity
+      let animator = UIViewPropertyAnimator(duration: animated ? 0.3 : 0, dampingRatio: 0.8) {
+        self.alpha = 0
+        self.transform = self.edgeTranslation
+      }
+      animator.addCompletion { [weak self] position in
+        self?.targetVisibility = nil
+        if position == .end {
+          self?.isHidden = true
+          self?.transform = .identity
         }
-      } else {
-        alpha = 0
-        isHidden = true
       }
+      currentAnimator = animator
+      animator.startAnimation()
     }
   }
 

package/ios/Modules/DevMenuPreferences.swift

@@ -42,7 +42,7 @@ public class DevMenuPreferences: Module {
       keyCommandsEnabledKey: true,
       showsAtLaunchKey: false,
       isOnboardingFinishedKey: false,
-      showFloatingActionButtonKey: false
+      showFloatingActionButtonKey: true
     ])
     #endif
 

package/ios/SwiftUI/DevMenuAppInfo.swift

@@ -12,8 +12,6 @@ struct DevMenuAppInfo: View {
         .foregroundColor(.primary.opacity(0.6))
 
       VStack(spacing: 0) {
-        Divider()
-
         InfoRow(title: "Version", value: viewModel.appInfo?.appVersion ?? "Unknown")
 
         if let runtimeVersion = viewModel.appInfo?.runtimeVersion {
@@ -44,8 +42,7 @@ struct DevMenuAppInfo: View {
         }
       }
       .padding(.horizontal)
-      .background(Color.expoSystemBackground)
-      .cornerRadius(18)
+      .background(Color.expoSecondarySystemBackground, in: RoundedRectangle(cornerRadius: 18))
     }
   }
 }

package/ios/SwiftUI/DevMenuButtons.swift

@@ -59,6 +59,8 @@ struct DevMenuToggleButton: View {
 
       Text(title)
         .foregroundColor(disabled ? .secondary : .primary)
+        .lineLimit(1)
+        .minimumScaleFactor(0.8)
 
       Spacer()
 

package/ios/SwiftUI/DevMenuDeveloperTools.swift

@@ -79,15 +79,14 @@ struct DevMenuDeveloperTools: View {
         Divider()
 
         DevMenuToggleButton(
-          title: "Show dev menu button",
+          title: "Tools button",
           icon: "hand.tap",
           isEnabled: viewModel.showFloatingActionButton,
           action: viewModel.toggleFloatingActionButton
         )
         #endif
       }
-      .background(Color.expoSystemBackground)
-      .cornerRadius(18)
+      .background(Color.expoSecondarySystemBackground, in: RoundedRectangle(cornerRadius: 18))
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-dev-menu",
-  "version": "55.0.8",
+  "version": "55.0.10",
   "description": "Expo/React Native module with the developer menu.",
   "main": "build/DevMenu.js",
   "types": "build/DevMenu.d.ts",
@@ -39,7 +39,7 @@
     "@babel/preset-typescript": "^7.7.4",
     "@testing-library/react-native": "^13.3.0",
     "babel-plugin-module-resolver": "^5.0.0",
-    "babel-preset-expo": "~55.0.7",
+    "babel-preset-expo": "~55.0.9",
     "expo-module-scripts": "^55.0.2",
     "react": "19.2.0",
     "react-native": "0.83.2"
@@ -47,5 +47,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "b183e5cbd95eb6ee54a878291c7077d8d63e4850"
+  "gitHead": "413b0450434d3e456eb391eca792ee9ac1e1efec"
 }