diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index b589d56..e58d3e4 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="17" />
+    <bytecodeTargetLevel target="19" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 0897082..f92acc2 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -5,7 +5,7 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
+        <option name="gradleJvm" value="corretto-19" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
index ae3f30a..f498f16 100644
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="19" />
+  </component>
   <component name="KotlinJpsPluginSettings">
     <option name="version" value="1.9.21" />
   </component>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 55c0ec2..35a1638 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" default="true" project-jdk-name="corretto-19" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">
diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml
deleted file mode 100644
index 7f68460..0000000
--- a/.idea/runConfigurations.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>
\ No newline at end of file
diff --git a/app/build.gradle b/app/build.gradle
index 16bf609..98d61d7 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -2,8 +2,7 @@ apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
 
 android {
-    compileSdkVersion 34
-    buildToolsVersion "30.0.3"
+    compileSdk 34
     namespace = "com.agronick.launcher"
 
     defaultConfig {
@@ -23,12 +22,12 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_19
+        targetCompatibility JavaVersion.VERSION_19
     }
 
     kotlinOptions{
-        jvmTarget = JavaVersion.VERSION_1_8
+        jvmTarget = JavaVersion.VERSION_19
     }
 }
 
@@ -42,6 +41,7 @@ dependencies {
     implementation 'androidx.legacy:legacy-support-v4:1.0.0'
     implementation 'androidx.recyclerview:recyclerview:1.3.2'
     implementation 'com.jakewharton.timber:timber:5.0.1'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
 
     implementation 'androidx.wear:wear:1.3.0'
     compileOnly 'com.google.android.wearable:wearable:2.9.0'
diff --git a/app/src/main/java/com/agronick/launcher/App.kt b/app/src/main/java/com/agronick/launcher/App.kt
index d672af2..1777bb7 100644
--- a/app/src/main/java/com/agronick/launcher/App.kt
+++ b/app/src/main/java/com/agronick/launcher/App.kt
@@ -2,51 +2,48 @@ package com.agronick.launcher
 
 import android.graphics.Canvas
 import android.graphics.Rect
-import androidx.core.graphics.drawable.toBitmap
 import util.geometry.Circle
 import util.geometry.CircleCircleIntersection
 import util.geometry.Vector2
 
+
 class App(val pkgInfo: PInfo, var size: Int) {
     var left = 0.0f
     var top = 0.0f
-    var bitmap = pkgInfo.icon.toBitmap(size * 2, size * 2)
+    var hidden = false
+    public var assignedPos: Pair<Int, Int>? = null
     private var lastCircle: Circle? = null
 
-    fun asOpenAnimator(endSize: Int): App {
+    fun copy(): App {
         val other = App(pkgInfo, size)
         other.left = left
         other.top = top
-        other.bitmap = pkgInfo.icon.toBitmap(endSize * 2, endSize * 2)
         return other
     }
 
     fun drawNormal(canvas: Canvas) {
-        if (lastCircle != null) {
-            val radius = lastCircle!!.r
-            draw(canvas, radius, left, top)
+        if (!hidden && lastCircle != null) {
+            val radius = lastCircle!!.r.coerceAtLeast(10f)
+            draw(canvas, radius, lastCircle!!.c.x, lastCircle!!.c.y)
         }
     }
 
-    fun prepare(faceCircle: Circle) {
-        lastCircle = getCircle(faceCircle) ?: return
+    fun prepare(faceCircle: Circle, checkCollisions: Boolean = true) {
+        lastCircle = getCircle(faceCircle, checkCollisions)
     }
 
-    fun draw(canvas: Canvas, radius: Float, x: Float, y: Float) {
-        canvas.drawBitmap(
-            bitmap,
-            null,
-            Rect(
-                (x - radius).toInt(),
-                (y - radius).toInt(),
-                (x + radius).toInt(),
-                (y + radius).toInt()
-            ),
-            null
+    private fun draw(canvas: Canvas, radius: Float, x: Float, y: Float) {
+        if (pkgInfo.icon == null) return
+        pkgInfo.icon!!.bounds = Rect(
+            (x - radius).toInt(),
+            (y - radius).toInt(),
+            (x + radius).toInt(),
+            (y + radius).toInt()
         )
+        pkgInfo.icon!!.draw(canvas)
     }
 
-    fun getCircle(faceCircle: Circle): Circle? {
+    private fun getCircle(faceCircle: Circle, checkCollisions: Boolean): Circle? {
         val startSize = size
         val appCircle = Circle(
             Vector2(
@@ -54,43 +51,61 @@ class App(val pkgInfo: PInfo, var size: Int) {
                 top
             ), startSize.toFloat()
         )
+        if (!checkCollisions) {
+            return appCircle
+        }
         val intersects =
             CircleCircleIntersection(faceCircle, appCircle)
+        if (intersects.type == CircleCircleIntersection.Type.SEPARATE) {
+            return null
+        }
         if (!intersects.type.isContained) {
-            if (intersects.type.intersectionPointCount == 0) return null
-            for (i in startSize.toLong() downTo 1) {
-                val testCircle = Circle(
-                    Vector2(
-                        left,
-                        top
-                    ), i.toFloat()
-                )
-                val intersector = CircleCircleIntersection(
-                    faceCircle,
-                    testCircle
+            val arcMidpoint = getArcMidpoint(intersects) ?: return null
+            val opposite = getPointClosestToCenter(faceCircle, appCircle)
+            return Circle(
+                arcMidpoint.midpoint(opposite),
+                arcMidpoint.distance(opposite) * 0.5f
+            )
+        }
+        return appCircle
+    }
+
+    private fun getArcMidpoint(intersection: CircleCircleIntersection): Vector2? {
+        return when (intersection.type.intersectionPointCount) {
+            1 -> intersection.intersectionPoint1
+            2 -> {
+                val AB = intersection.intersectionPoint2.sub(intersection.intersectionPoint1)
+                val lAB = kotlin.math.sqrt(AB.x * AB.x + AB.y * AB.y)
+                val uAB = Vector2(AB.x / lAB, AB.y / lAB)
+                val mAB = intersection.intersectionPoint1.add(intersection.intersectionPoint2).div(
+                    2f
                 )
-                if (intersector.type.intersectionPointCount == 0) {
-                    return testCircle
-                }
+                val R = intersection.c1.r
+                val F = R - kotlin.math.sqrt(R * R - lAB * lAB * 0.25f)
+                Vector2(mAB.x - uAB.y * F, mAB.y + uAB.x * F)
             }
-            return null
+            else -> null
         }
-        return appCircle
     }
 
-    fun intersects(x: Float, y: Float): Boolean {
-        if (null == lastCircle) return false
-        val circle = getCircle(lastCircle!!)
-        val point = Circle(
-            Vector2(
-                x,
-                y
-            ), 3.0f
-        )
-        return CircleCircleIntersection(
-            circle,
-            point
-        ).type == CircleCircleIntersection.Type.ECCENTRIC_CONTAINED
+    private fun getPointClosestToCenter(faceCircle: Circle, appCircle: Circle): Vector2 {
+        val vX = faceCircle.c.x - appCircle.c.x
+        val vY = faceCircle.c.y - appCircle.c.y
+        val magV = kotlin.math.sqrt((vX * vX + vY * vY).toDouble()).toFloat()
+        val aX = appCircle.c.x + vX / magV * appCircle.r
+        val aY = appCircle.c.y + vY / magV * appCircle.r
+        return Vector2(aX, aY)
+    }
+
+    fun intersects(point: Vector2): Boolean {
+        val circle = lastCircle
+        if (circle != null) {
+            return CircleCircleIntersection(
+                circle,
+                Circle(point, 3.0f)
+            ).type == CircleCircleIntersection.Type.ECCENTRIC_CONTAINED
+        }
+        return false
     }
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/agronick/launcher/AppListProvider.kt b/app/src/main/java/com/agronick/launcher/AppListProvider.kt
new file mode 100644
index 0000000..6310d60
--- /dev/null
+++ b/app/src/main/java/com/agronick/launcher/AppListProvider.kt
@@ -0,0 +1,108 @@
+package com.agronick.launcher
+
+import android.content.Context
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import timber.log.Timber
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+
+
+class AppListProvider(val appList: List<PInfo>, context: Context) {
+
+    val positions = HashMap<Int, HashMap<Int, PInfo?>>().withDefault { HashMap() }
+    val filePath = "${context.dataDir}/appPositions.json"
+    val mapping = appList.map {
+        it.asKey() to it
+    }.toMap().toMutableMap()
+    val unregisted = mapping.keys.toMutableList()
+    val totalItems = appList.size
+
+    fun load() {
+        positions.clear()
+        if (!File(filePath).exists()) {
+            Timber.i("No file found. Will create first file shortly.")
+            return
+        }
+        val file = FileReader(filePath)
+        file.readText().let {
+            val json = JSONObject(it)
+            json.keys().forEach { rowKey ->
+                val rowInt = rowKey.toInt()
+                val row = json.getJSONObject(rowKey)
+                val rowFinal = positions.getOrPut(
+                    rowInt,
+                ) {
+                    HashMap()
+                }
+                row.keys().forEach { colId ->
+                    val col = row.getString(colId)
+                    unregisted.remove(col)
+                    rowFinal[colId.toInt()] = mapping.getOrDefault(col, PInfo.getBlank())
+                }
+            }
+        }
+    }
+
+    fun getPkgIterator(): PkgIterator {
+        return PkgIterator(mapping, unregisted, positions)
+    }
+
+    class PkgIterator(
+        val mapping: MutableMap<String, PInfo>,
+        val unregistered: MutableList<String>,
+        val positions: MutableMap<Int, HashMap<Int, PInfo?>>,
+    ) {
+        val touchedItems = mapping.keys.toMutableSet()
+
+        fun get(x: Int, y: Int): PInfo? {
+            val found = positions.getOrPut(x) {
+                HashMap()
+            }.getOrPut(y) {
+                unregistered.removeLastOrNull()?.let {
+                    mapping[it]
+                }
+            }
+            Timber.d("Requesting app for $x $y got ${found?.appname}")
+            return found?.also {
+                touchedItems.remove(it.asKey())
+            }
+        }
+
+        fun hasMore(): Boolean {
+            return touchedItems.isNotEmpty()
+        }
+    }
+
+    fun save() {
+        GlobalScope.launch(Dispatchers.IO) {
+            val jsonObject = JSONObject()
+            positions.forEach {
+                jsonObject.put(it.key.toString(), JSONObject().apply {
+                    it.value.forEach {
+                        put(it.key.toString(), it.value?.asKey())
+                    }
+                })
+            }
+            val file = FileWriter(filePath)
+            file.write(jsonObject.toString())
+            file.flush()
+            file.close()
+        }
+    }
+
+    fun swap(app1: App, app2: App) {
+        (app1.assignedPos to app2.assignedPos).apply {
+            app2.assignedPos = first
+            app1.assignedPos = second
+        }
+        arrayOf(app1, app2).forEach {
+            val toPlace = if (it.pkgInfo.isBlank()) null else it.pkgInfo
+            positions[it.assignedPos!!.first]!![it.assignedPos!!.second] = toPlace
+        }
+    }
+}
+
diff --git a/app/src/main/java/com/agronick/launcher/Container.kt b/app/src/main/java/com/agronick/launcher/Container.kt
index 16da716..725d797 100644
--- a/app/src/main/java/com/agronick/launcher/Container.kt
+++ b/app/src/main/java/com/agronick/launcher/Container.kt
@@ -4,13 +4,15 @@ import android.graphics.Canvas
 import util.geometry.Circle
 import util.geometry.Vector2
 import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.roundToInt
 import kotlin.math.sqrt
 
-class Container(appList: List<PInfo>) {
-    private val rows: List<List<App>>
-    val size = 48
-    val margin = 2
-    private val iterate: Sequence<Triple<App, Int, Int>>
+class Container(val appList: AppListProvider, density: Float) {
+    private val rows: List<List<List<App>>>
+    val appCircleSize = (StaticValues.normalAppSize * density).roundToInt()
+    val appCircleMargin = (StaticValues.margin * density).roundToInt()
+    private val iterate: List<App>
     var lastCircle: Circle? = null
 
     var topLimit = 0f
@@ -20,44 +22,75 @@ class Container(appList: List<PInfo>) {
 
     private var equalizerOffset = 1.1f
 
+    companion object {
+        private const val tag = "Container"
+    }
+
     init {
-        val squareSize = Math.ceil(sqrt(appList.size.toFloat()).toDouble()).toInt()
-        val appIter = appList.iterator()
-        rows = 1.rangeTo(squareSize).mapNotNull outer@{
-            val cols = 1.rangeTo(squareSize).mapNotNull inner@{
-                if (appIter.hasNext()) {
-                    return@inner App(
-                        appIter.next(),
-                        size
-                    )
+        /*
+        Tries to set up a rough circle shape
+        Rows are stored using the outer array index as y pos and inner array as x pos
+        The middle array holds up to 2 items, one to be drawn at positive y and one at negative y
+        rows = [
+           [[row at y], [row at y index * -1]]
+        ]
+         */
+        // Area of a circle to radius
+        val appRadius = sqrt(appList.totalItems.toFloat() / Math.PI)
+        val appDiam = appRadius * 2
+        val appRadiusSquared = appRadius * appRadius
+        val pkgIterator = appList.getPkgIterator()
+        rows = 0.rangeTo(floor(appRadius).toInt()).mapNotNull outer@{ row ->
+            // Pythagorean theorem - row length at each level
+            val rowDiam =
+                ((if (row == 0) appDiam else (sqrt(appRadiusSquared - (row * row)) * 2) - 1)).roundToInt()
+            val rowGroup = (0..(
+                    if (row == 0) 0 else 1)
+                    ).mapNotNull middle@{ sect ->
+                    val cols = (0..rowDiam).mapNotNull inner@{ col ->
+                        if (pkgIterator.hasMore()) {
+                            return@inner App(
+                                pkgIterator.get(
+                                    row, if (sect == 0) {
+                                        col
+                                    } else {
+                                        -col
+                                    }
+                                ) ?: PInfo.getBlank(),
+                                appCircleSize
+                            )
+                        }
+                        return@inner null
+                    }
+                    return@middle cols.ifEmpty { null }
                 }
-                return@inner null
-            }
-            return@outer if (cols.isNotEmpty()) cols else null
+            return@outer rowGroup.ifEmpty { null }
         }
+
+
+        appList.save()
+
         iterate = sequence {
-            val iterator = this@Container.rows.iterator()
-            var rowCount = 0
-            while (iterator.hasNext()) {
-                val row = iterator.next()
-                val colIterator = row.iterator()
-                var colCount = 0
-                while (colIterator.hasNext()) {
-                    val app = colIterator.next()
-                    yield(Triple(app, rowCount, colCount))
-                    colCount++
+            rows.forEachIndexed { rowCount, parts ->
+                parts.getOrNull(0)?.forEachIndexed { colCount, app ->
+                    yield(app.apply {
+                        assignedPos = Pair(rowCount, colCount)
+                    })
+                }
+                parts.getOrNull(1)?.forEachIndexed { colCount, app ->
+                    yield(app.apply {
+                        assignedPos = Pair(-rowCount, colCount)
+                    })
                 }
-                rowCount += 1
             }
-        }
+        }.toList()
         position()
     }
 
 
     private fun position() {
-        iterate.forEach {
-            val app = it.first
-            val positions = calcPositions(it.second, it.third)
+        iterate.forEach { app ->
+            val positions = calcPositions(app.assignedPos!!.first, app.assignedPos!!.second)
             app.left = positions.first
             app.top = positions.second
 
@@ -81,30 +114,36 @@ class Container(appList: List<PInfo>) {
 
     fun draw(canvas: Canvas) {
         iterate.forEach {
-            it.first.drawNormal(canvas)
+            it.drawNormal(canvas)
         }
     }
 
     private fun calcPositions(row: Int, col: Int): Pair<Float, Float> {
         var left = calcPosition(col) * equalizerOffset
-        if (ceil(row * 0.5) % 2 == 1.0) {
-            left -= size + margin
+        if (kotlin.math.abs(row) % 2 == 1) {
+            // Add offset for haxagon shape
+            left -= appCircleSize + appCircleMargin
         }
-        val top = calcPosition(row)
+        val top = (row * (appCircleSize * 2) + row * appCircleMargin).toFloat()
         return Pair(left, top)
     }
 
     private fun calcPosition(num: Int): Float {
         var pos = ceil(num * 0.5f)
-        pos = (pos * (size * 2) + pos * margin)
+        pos = pos * (appCircleSize * 2) + pos * appCircleMargin
         if (num % 2 == 0) {
+            // Position right, the left of center
             pos *= -1
         }
         return pos
     }
 
-    fun getClickedPackage(x: Float, y: Float): App? {
-        return iterate.find { it.first.intersects(x, y) }?.first
+    fun getAppAtPoint(point: Vector2, toIgnore: HashSet<App>? = null): App? {
+        return iterate.find {
+            (if (toIgnore != null) !toIgnore.contains(it) else true) && it.intersects(
+                point
+            )
+        }
     }
 
     fun prepare(offsetLeft: Float, offsetTop: Float, size: Float) {
@@ -115,12 +154,12 @@ class Container(appList: List<PInfo>) {
             ), ceil(size * 0.5).toFloat()
         )
         iterate.forEach {
-            it.first.prepare(lastCircle!!)
+            it.prepare(lastCircle!!)
         }
     }
 
     fun getLimit(x: Float, y: Float, size: Float): Pair<Float, Float> {
-        val halfSize = size * 0.5f
+        val halfSize = (lastCircle?.r ?: size) * 0.75f
         var outX = x
         var outY = y
         if (x - halfSize < leftLimit) {
diff --git a/app/src/main/java/com/agronick/launcher/Launcher.kt b/app/src/main/java/com/agronick/launcher/Launcher.kt
new file mode 100644
index 0000000..7c98333
--- /dev/null
+++ b/app/src/main/java/com/agronick/launcher/Launcher.kt
@@ -0,0 +1,18 @@
+package com.agronick.launcher
+
+import android.app.Application
+import android.content.Context
+import timber.log.Timber
+
+class Launcher : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+        appContext = applicationContext
+        Timber.plant(Timber.DebugTree())
+    }
+
+    companion object {
+        lateinit var appContext: Context
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/agronick/launcher/MainActivity.kt b/app/src/main/java/com/agronick/launcher/MainActivity.kt
index 1eabaca..87f52c9 100644
--- a/app/src/main/java/com/agronick/launcher/MainActivity.kt
+++ b/app/src/main/java/com/agronick/launcher/MainActivity.kt
@@ -5,12 +5,17 @@ import android.content.ComponentName
 import android.content.Intent
 import android.os.Bundle
 import android.transition.Fade
+import android.view.GestureDetector
+import android.view.MotionEvent
 import android.view.Window
+import androidx.core.view.GestureDetectorCompat
 
 
-
-class MainActivity : Activity() {
+class MainActivity : Activity(), GestureDetector.OnGestureListener {
+    private var wasScrolling = false
+    private lateinit var mDetector: GestureDetectorCompat
     private lateinit var mainView: MainView
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         with(window) {
@@ -22,23 +27,43 @@ class MainActivity : Activity() {
         }
 
         mainView = MainView(this.baseContext, getInstalledApps())
+        if (savedInstanceState != null) {
+            mainView.offsetLeft = savedInstanceState.getFloat("offsetLeft")
+            mainView.offsetTop = savedInstanceState.getFloat("offsetTop")
+        }
+
         setContentView(mainView)
         mainView.onPackageClick = this::onPackageClick
+
+        mDetector = GestureDetectorCompat(this, this)
+        mDetector.setIsLongpressEnabled(true)
     }
 
-    override fun onPause() {
-        super.onPause()
-        mainView.invalidate()
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        return if (mDetector.onTouchEvent(event)) {
+            true
+        } else if (mainView.reorderer != null) {
+            mainView.handleLongPress(event)
+            return true
+        } else if (wasScrolling && event.action == MotionEvent.ACTION_UP) {
+            mainView.checkOverPanLimit()
+            wasScrolling = false
+            return true
+        } else {
+            super.onTouchEvent(event)
+        }
     }
 
+
     fun onPackageClick(pkg: PInfo) {
-        val name = ComponentName(pkg.pname, pkg.activityName)
-        with(Intent(Intent.ACTION_MAIN)) {
-            addCategory(Intent.CATEGORY_LAUNCHER)
-            flags = Intent.FLAG_ACTIVITY_NEW_TASK or
+        if (pkg.pname != null && pkg.activityName != null) {
+            val name = ComponentName(pkg.pname!!, pkg.activityName!!)
+            val i = Intent(Intent.ACTION_MAIN)
+            i.addCategory(Intent.CATEGORY_LAUNCHER)
+            i.flags = Intent.FLAG_ACTIVITY_NEW_TASK or
                     Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
-            component = name
-            startActivity(this)
+            i.component = name
+            startActivity(i)
         }
     }
 
@@ -46,13 +71,77 @@ class MainActivity : Activity() {
         val mainIntent = Intent(Intent.ACTION_MAIN, null)
         mainIntent.addCategory(Intent.CATEGORY_LAUNCHER)
         return packageManager.queryIntentActivities(mainIntent, 0).mapNotNull {
-            return@mapNotNull PInfo(
+            if (it.activityInfo.packageName.startsWith("com.agronick.launcher")) {
+                return@mapNotNull null
+            }
+            PInfo(
                 appname = it.activityInfo.packageName,
                 pname = it.activityInfo.packageName,
                 icon = it.activityInfo.loadIcon(packageManager),
-                activityName = it.activityInfo.name
+                activityName = it.activityInfo.name,
             )
         }
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        outState.putFloat("offsetLeft", mainView.offsetLeft)
+        outState.putFloat("offsetTop", mainView.offsetTop)
+        super.onSaveInstanceState(outState)
+    }
+
+    override fun onPause() {
+        super.onPause()
+        mainView.openingApp = null
+        mainView.allHidden = true
+        mainView.invalidate()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (mainView.allHidden) {
+            mainView.allHidden = false
+            mainView.invalidate()
+        }
+    }
+
+    override fun onDown(e: MotionEvent): Boolean {
+        return false
+    }
+
+    override fun onShowPress(e: MotionEvent) {
+
+    }
+
+    override fun onSingleTapUp(e: MotionEvent): Boolean {
+        mainView.handleClick(e.x, e.y)
+        return true
+    }
+
+    override fun onScroll(
+        e1: MotionEvent?,
+        e2: MotionEvent,
+        distanceX: Float,
+        distanceY: Float
+    ): Boolean {
+        mainView.offsetLeft -= distanceX
+        mainView.offsetTop -= distanceY
+        mainView.prepareInvalidate()
+        wasScrolling = true
+        return true
+    }
+
+    override fun onLongPress(e: MotionEvent) {
+        if (e != null) {
+            mainView.handleLongPress(e)
+        }
+    }
+
+    override fun onFling(
+        e1: MotionEvent?,
+        e2: MotionEvent,
+        velocityX: Float,
+        velocityY: Float
+    ): Boolean {
+        return false
+    }
 }
diff --git a/app/src/main/java/com/agronick/launcher/MainView.kt b/app/src/main/java/com/agronick/launcher/MainView.kt
index 16497f7..e625057 100644
--- a/app/src/main/java/com/agronick/launcher/MainView.kt
+++ b/app/src/main/java/com/agronick/launcher/MainView.kt
@@ -4,77 +4,166 @@ import android.animation.AnimatorSet
 import android.animation.ValueAnimator
 import android.content.Context
 import android.graphics.Canvas
+import android.view.HapticFeedbackConstants
 import android.view.MotionEvent
 import android.view.View
 import androidx.core.animation.doOnEnd
-import timber.log.Timber
+import util.geometry.Vector2
+import java.util.*
 
 class MainView(context: Context, appList: List<PInfo>) : View(context) {
+    private var edgeTimer: Timer? = null
+    private var density: Float = context.resources.displayMetrics.density
+    var onPackageClick: ((PInfo) -> Unit)? = null
+
+    private lateinit var container: Container
+    var offsetLeft = 0f
+    var offsetTop = 0f
+    private var canvasSize: Float = 0f
+    private var edgeLimit = 100000f
+    var allHidden = false
+
+    private val STATE_NONE = 0
+    private val STATE_REORDERING = 1
+    private val STATE_OPENING = 2
+
+    private fun getActiveState(): Int {
+        if (reorderer != null) return STATE_REORDERING
+        if (openingApp != null) return STATE_OPENING
+        return STATE_NONE
+    }
+
+    var openingApp: App? = null
+
     init {
         Runnable {
-            container = Container(appList)
+            val appListProvider = AppListProvider(appList, context)
+            appListProvider.load()
+            container = Container(appListProvider, density)
         }.run()
     }
 
-    var onPackageClick: ((PInfo) -> Unit)? = null
-
-    private lateinit var container: Container
-    private var offsetLeft = 0f
-    private var offsetTop = 0f
+    var reorderer: Reorderer? = null
 
-    private var previousX: Float = 0f
-    private var previousY: Float = 0f
-    private var hasMoved = false
-    private var canvasSize: Float = 0f
+    fun handleScroll(distanceX: Float, distanceY: Float) {
+        if (getActiveState() != STATE_NONE) return
+        offsetLeft -= distanceX
+        offsetTop -= distanceY
+        prepareInvalidate()
+    }
 
-    private var openingApp: App? = null
+    fun resetReorderEdgeTimer() {
+        edgeTimer?.cancel()
+    }
 
-    override fun onTouchEvent(event: MotionEvent?): Boolean {
-        if (event != null) {
-            when (event.action) {
-                MotionEvent.ACTION_DOWN -> {
-                    previousX = event.x
-                    previousY = event.y
-                    hasMoved = false
-                    return true
+    fun reorderAtEdge(newOffsets: Vector2) {
+        resetReorderEdgeTimer()
+        edgeTimer = Timer()
+        edgeTimer?.schedule(object : TimerTask() {
+            override fun run() {
+                offsetLeft += newOffsets.x
+                offsetTop += newOffsets.y
+                val curReorderer = reorderer
+                if (curReorderer !== null) {
+                    val appPos = curReorderer.getAppPos()
+                    post {
+                        curReorderer.onMove(
+                            Vector2(
+                                appPos.x - newOffsets.x,
+                                appPos.y - newOffsets.y
+                            )
+                        )
+                    }
                 }
-                MotionEvent.ACTION_MOVE -> {
-                    val newOffsetLeft = offsetLeft + event.x - previousX
-                    val newOffsetTop = offsetTop + event.y - previousY
-                    val limited = container.getLimit(newOffsetLeft, newOffsetTop, canvasSize)
-                    offsetLeft = limited.first
-                    offsetTop = limited.second
-                    if (newOffsetLeft == limited.first) {
-                        previousX = event.x
+                prepareInvalidate()
+            }
+        }, 0, 33)
+    }
+
+    fun handleLongPress(event: MotionEvent) {
+        val state = getActiveState()
+        if (state == STATE_OPENING) return
+        val offset = getRelativePosition(Pair(event.x, event.y))
+        if (state == STATE_REORDERING) {
+            if (event.action == MotionEvent.ACTION_UP) {
+                reorderer!!.onStopReorder(
+                    when (container.getLimit(offsetLeft, offsetTop, canvasSize)) {
+                        Pair(offsetLeft, offsetTop) -> container.getAppAtPoint(
+                            Vector2(
+                                offset.x,
+                                offset.y
+                            )
+                        )
+                        else -> null
                     }
-                    if (newOffsetTop == limited.second) {
-                        previousY = event.y
+                )
+                reorderer = null
+                resetReorderEdgeTimer()
+            } else {
+                reorderer!!.onMove(offset)
+                val newOffsets =
+                    reorderer!!.checkAtEdge(offset, container.lastCircle, density * 0.3f)
+                if (newOffsets != null) {
+                    reorderAtEdge(newOffsets.scale(density * 3))
+                } else {
+                    resetReorderEdgeTimer()
+                }
+                prepareInvalidate()
+            }
+        } else if (state == STATE_NONE) {
+            val app = container.getAppAtPoint(Vector2(offset.x, offset.y))
+            if (app != null) {
+                post {
+                    reorderer = Reorderer(container, app, ::prepareInvalidate)
+                    performHapticFeedback(HapticFeedbackConstants.CONTEXT_CLICK)
+                }
+            }
+        }
+    }
+
+    fun checkOverPanLimit() {
+        val limited = container.getLimit(offsetLeft, offsetTop, canvasSize)
+        val animators = mutableListOf<ValueAnimator>()
+        if (offsetLeft != limited.first) {
+            animators.add(ValueAnimator.ofFloat(offsetLeft, limited.first)
+                .apply {
+                    addUpdateListener { animator ->
+                        offsetLeft = animator.animatedValue as Float
                     }
-                    hasMoved = true
-                    prepareInvalidate()
-                    return true
                 }
-                MotionEvent.ACTION_UP -> {
-                    if (!hasMoved) {
-                        handleClick(event.x, event.y)
+            )
+        }
+        if (offsetTop != limited.second) {
+            animators.add(ValueAnimator.ofFloat(offsetTop, limited.second)
+                .apply {
+                    addUpdateListener { animator ->
+                        offsetTop = animator.animatedValue as Float
                     }
                 }
+            )
+        }
+        if (animators.isNotEmpty()) {
+            animators[0].addUpdateListener { prepareInvalidate() }
+            AnimatorSet().apply {
+                duration = StaticValues.durationOpen
+                playTogether(*animators.toTypedArray())
+                start()
             }
         }
-        return super.onTouchEvent(event)
     }
 
     fun handleClick(x: Float, y: Float) {
-        val offset = getOffset()
-        if (offset != null) {
-            val app = container.getClickedPackage(x - offset.first, y - offset.second)
-            if (app != null) {
-                setupOpenAnim(app.asOpenAnimator(canvasSize.toInt()))
-            }
+        if (getActiveState() != STATE_NONE) return
+        val offset = getRelativePosition(Pair(x, y))
+        val app = container.getAppAtPoint(offset)
+        if (app != null && app.pkgInfo.activityName != null) {
+            setupOpenAnim(app.copy())
         }
     }
 
     fun setupOpenAnim(app: App) {
+        if (getActiveState() != STATE_NONE) return
+
         val face = container.lastCircle ?: return
         openingApp = app
 
@@ -91,12 +180,11 @@ class MainView(context: Context, appList: List<PInfo>) : View(context) {
                 }
             }
         val radiusAnimator =
-            ValueAnimator.ofFloat(app.size.toFloat(), canvasSize)
+            ValueAnimator.ofFloat(app.size.toFloat(), canvasSize * 0.5f)
                 .apply {
                     addUpdateListener { animator ->
                         app.size = ((animator.animatedValue as Float).toInt())
-                        Timber.d("At size ${app.size}")
-                        container.lastCircle?.let { app.prepare(it) }
+                        container.lastCircle?.let { app.prepare(it, false) }
                         invalidate()
                     }
                 }
@@ -106,8 +194,8 @@ class MainView(context: Context, appList: List<PInfo>) : View(context) {
             playTogether(xAnimator, yAnimator, radiusAnimator)
             doOnEnd {
                 postDelayed({
-                    openingApp = null
                     onPackageClick?.let { it1 -> it1(app.pkgInfo) }
+                    openingApp = null
                 }, 200)
             }
             start()
@@ -115,33 +203,35 @@ class MainView(context: Context, appList: List<PInfo>) : View(context) {
     }
 
     override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-        canvasSize = Math.min(w, h).toFloat()
+        canvasSize = w.coerceAtMost(h).toFloat()
+        edgeLimit = canvasSize * 0.9f
         container.prepare(offsetLeft, offsetTop, w.toFloat())
         super.onSizeChanged(w, h, oldw, oldh)
     }
 
-    fun getOffset(): Pair<Float, Float>? {
+    fun getRelativePosition(point: Pair<Float, Float>? = null): Vector2 {
         val halfSize = canvasSize * 0.5f
-        return Pair(halfSize + offsetLeft, halfSize + offsetTop)
+        val pos = Vector2(halfSize + offsetLeft, halfSize + offsetTop)
+        if (point != null) {
+            return Vector2(point.first - pos.x, point.second - pos.y)
+        }
+        return pos
     }
 
     fun prepareInvalidate() {
         if (canvasSize == 0f) return
         Runnable {
             container.prepare(offsetLeft, offsetTop, canvasSize)
+            reorderer?.prepare()
             invalidate()
         }.run()
     }
 
     override fun onDraw(canvas: Canvas) {
-        Timber.d(
-            "draw called $offsetLeft $offsetTop"
-        )
-        val offset = getOffset()
-        if (offset != null) {
-            canvas.translate(offset.first, offset.second)
-            container.draw(canvas)
-            openingApp?.drawNormal(canvas)
-        }
+        if (allHidden) return
+        val offset = getRelativePosition()
+        canvas.translate(offset.x, offset.y)
+        container.draw(canvas)
+        openingApp?.drawNormal(canvas)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/agronick/launcher/PInfo.kt b/app/src/main/java/com/agronick/launcher/PInfo.kt
index 76f55fc..e0f3b49 100644
--- a/app/src/main/java/com/agronick/launcher/PInfo.kt
+++ b/app/src/main/java/com/agronick/launcher/PInfo.kt
@@ -2,4 +2,27 @@ package com.agronick.launcher
 
 import android.graphics.drawable.Drawable
 
-class PInfo(var appname: String, var pname: String, var icon: Drawable, var activityName: String)
\ No newline at end of file
+class PInfo(
+    var appname: String?,
+    var pname: String?,
+    var icon: Drawable?,
+    var activityName: String?,
+) {
+    companion object {
+        fun getBlank(): PInfo {
+            return PInfo(
+                appname = null,
+                pname = null,
+                icon = null,
+                activityName = null
+            )
+        }
+    }
+    fun asKey(): String {
+        return "${appname}:${activityName}"
+    }
+
+    fun isBlank(): Boolean {
+        return appname == null
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/agronick/launcher/Reorderer.kt b/app/src/main/java/com/agronick/launcher/Reorderer.kt
new file mode 100644
index 0000000..bcddcd2
--- /dev/null
+++ b/app/src/main/java/com/agronick/launcher/Reorderer.kt
@@ -0,0 +1,98 @@
+package com.agronick.launcher
+
+import android.animation.AnimatorSet
+import android.animation.ValueAnimator
+import androidx.core.animation.doOnEnd
+import kotlinx.coroutines.GlobalScope
+import util.geometry.Circle
+import util.geometry.Vector2
+
+class Reorderer(
+    private val container: Container,
+    private var app: App,
+    val invalidate: () -> Unit,
+) {
+    private var suppressedAppCopy: App = app.copy()
+    private var lastPosition = HashSet<App>()
+    private val defaultCircleSize = container.appCircleSize
+    private val appList = container.appList
+
+    init {
+        lastPosition.add(app)
+        suppressedAppCopy.hidden = true
+        ValueAnimator.ofInt(app.size, (app.size * 1.4).toInt())
+            .apply {
+                duration = StaticValues.durationRise
+                addUpdateListener { animator ->
+                    app.size = animator.animatedValue as Int
+                    invalidate()
+                }
+            }.start()
+    }
+
+    fun onMove(position: Vector2) {
+        app.left = position.x
+        app.top = position.y
+    }
+
+    fun getAppPos(): Vector2 {
+        return Vector2(app.left, app.top)
+    }
+
+    fun animateAppPosition(app: App, x: Float, y: Float) {
+        val xAnim = ValueAnimator.ofFloat(app.left, x).apply {
+            duration = StaticValues.durationSwap
+            addUpdateListener { animator ->
+                app.left = animator.animatedValue as Float
+                invalidate()
+            }
+        }
+        val yAnim = ValueAnimator.ofFloat(app.top, y).apply {
+            duration = StaticValues.durationSwap
+            addUpdateListener { animator ->
+                app.top = animator.animatedValue as Float
+            }
+        }
+        AnimatorSet().apply {
+            duration = StaticValues.durationOpen
+            playTogether(xAnim, yAnim)
+            doOnEnd {
+                lastPosition.remove(app)
+            }
+            start()
+        }
+    }
+
+    fun onStopReorder(overApp: App?) {
+        if (overApp == null) {
+            animateAppPosition(app, suppressedAppCopy.left, suppressedAppCopy.top)
+        } else {
+            animateAppPosition(overApp, suppressedAppCopy.left, suppressedAppCopy.top)
+            animateAppPosition(app, overApp.left, overApp.top)
+            appList.swap(app, overApp)
+            appList.save()
+        }
+        ValueAnimator.ofInt((suppressedAppCopy.size * 1.4).toInt(), defaultCircleSize)
+            .apply {
+                duration = StaticValues.durationRise
+                addUpdateListener { animator ->
+                    app.size = animator.animatedValue as Int
+                }
+            }.start()
+    }
+
+    fun prepare() {
+        container.lastCircle?.let { app.prepare(it, false) }
+    }
+
+    fun checkAtEdge(offsetVector: Vector2, lastCircle: Circle?, density: Float): Vector2? {
+        if (lastCircle == null) return null
+        val maxDistance = lastCircle.r * density
+        if (offsetVector.distance(lastCircle.c) >= maxDistance) {
+            val angle = Math.toRadians(lastCircle.c.angleBetween(offsetVector)).toFloat()
+            return Vector2(kotlin.math.sin(angle) * -2, kotlin.math.cos(angle) * 2)
+        }
+        return null
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/agronick/launcher/StaticValues.kt b/app/src/main/java/com/agronick/launcher/StaticValues.kt
new file mode 100644
index 0000000..f4769c3
--- /dev/null
+++ b/app/src/main/java/com/agronick/launcher/StaticValues.kt
@@ -0,0 +1,12 @@
+package com.agronick.launcher
+
+class StaticValues {
+    companion object {
+        val margin = 1
+        val normalAppSize = 24
+        val durationRise = 300L
+        val durationSwap = 300L
+        val durationOpen = 600L
+        val tag = "Flattery"
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/util/geometry/Vector2.java b/app/src/main/java/util/geometry/Vector2.java
index dd208a4..7b72319 100644
--- a/app/src/main/java/util/geometry/Vector2.java
+++ b/app/src/main/java/util/geometry/Vector2.java
@@ -63,6 +63,32 @@ public float angle() {
         return (float) atan2(y, x);
     }
 
+    public Vector2 div(float a) {
+        return new Vector2(x / a, y / a);
+    }
+
+    public Vector2 div(Vector2 a) {
+        return new Vector2(x / a.x, y / a.y);
+    }
+
+    public Vector2 midpoint(Vector2 a) {
+        return new Vector2(this.x + a.x, this.y + a.y).div(2f);
+    }
+
+    public float distance(Vector2 a) {
+        return (float) Math.sqrt(Math.pow((a.x - this.x), 2) + Math.pow((a.y - this.y), 2));
+    }
+
+    /**
+     * Returns the angle between the given two points
+     */
+    public double angleBetween(Vector2 a) {
+        Vector2 diff = this.sub(a);
+        double angle = Math.atan2(diff.y, diff.x);
+        double degrees = 180 * angle / Math.PI;
+        return ((360 + Math.round(degrees)) - 90) % 360;
+    }
+
     @Override
     public int hashCode() {
         final int prime = 31;
diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml
index e865b41..f1b9f95 100644
--- a/app/src/main/res/values/dimens.xml
+++ b/app/src/main/res/values/dimens.xml
@@ -1,15 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!--
-    Because the window insets on round devices are larger than 15dp, this padding only applies
-    to square screens.
-    -->
-    <dimen name="box_inset_layout_padding">0dp</dimen>
-
-    <!--
-    This padding applies to both square and round screens. The total padding between the buttons
-    and the window insets is box_inset_layout_padding (above variable) on square screens and
-    inner_frame_layout_padding (below variable) on round screens.
-    -->
-    <dimen name="inner_frame_layout_padding">5dp</dimen>
+    <dimen name="app_size">28</dimen>
+    <dimen name="margin">1</dimen>
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 41d30d5..dbf2642 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -4,5 +4,5 @@
     This string is used for square devices and overridden by hello_world in
     values-round/strings.xml for round devices.
     -->
-    <string name="hello_world">Hello Square World!</string>
+    <string name="max_rows">Max rows</string>
 </resources>
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a58bba9..1af9e09 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,7 @@
-#Fri Dec 15 09:53:45 EST 2023
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 1b6c787..fcb6fca 100644
--- a/gradlew
+++ b/gradlew
@@ -55,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +80,10 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,22 +130,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -193,6 +197,10 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
 # Collect all arguments for the java command;
 #   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
 #     shell script including quotes and variable substitutions, so put them in
@@ -205,6 +213,12 @@ set -- \
         org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
diff --git a/gradlew.bat b/gradlew.bat
index 107acd3..93e3f59 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +25,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal