diff --git a/api/Main.run.xml b/api/Main.run.xml
index 7968b5ad8..2d1a2e146 100644
--- a/api/Main.run.xml
+++ b/api/Main.run.xml
@@ -1,19 +1,11 @@
 <component name="ProjectRunConfigurationManager">
-    <configuration default="false"
-                   name="Main"
-                   type="JetRunConfigurationType">
-        <option name="MAIN_CLASS_NAME"
-                value="nebulosa.api.MainKt"/>
+    <configuration default="false" name="Main" type="JetRunConfigurationType">
+        <option name="MAIN_CLASS_NAME" value="nebulosa.api.MainKt"/>
         <module name="nebulosa.api.main"/>
-        <option name="PROGRAM_PARAMETERS"
-                value="--port=7000"/>
+        <option name="PROGRAM_PARAMETERS" value="--port=7000 --debug"/>
         <shortenClasspath name="NONE"/>
         <method v="2">
-            <option name="Gradle.BeforeRunTask"
-                    enabled="true"
-                    tasks="build"
-                    externalProjectPath="$PROJECT_DIR$/api"
-                    vmOptions=""
+            <option name="Gradle.BeforeRunTask" enabled="true" tasks="build" externalProjectPath="$PROJECT_DIR$/api" vmOptions=""
                     scriptParameters="-x test"/>
         </method>
     </configuration>
diff --git a/api/build.gradle.kts b/api/build.gradle.kts
index 8c44235c6..eab48ae25 100644
--- a/api/build.gradle.kts
+++ b/api/build.gradle.kts
@@ -12,6 +12,7 @@ dependencies {
     implementation(project(":nebulosa-astap"))
     implementation(project(":nebulosa-astrometrynet"))
     implementation(project(":nebulosa-alpaca-indi"))
+    implementation(project(":nebulosa-autofocus"))
     implementation(project(":nebulosa-curve-fitting"))
     implementation(project(":nebulosa-guiding-phd2"))
     implementation(project(":nebulosa-hips2fits"))
diff --git a/api/src/main/kotlin/nebulosa/api/Nebulosa.kt b/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
index de53ec499..167795a46 100644
--- a/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
+++ b/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
@@ -1,5 +1,6 @@
 package nebulosa.api
 
+import ch.qos.logback.classic.Level
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
@@ -14,6 +15,7 @@ import nebulosa.api.inject.*
 import nebulosa.json.PathModule
 import nebulosa.log.loggerFor
 import org.koin.core.context.startKoin
+import org.slf4j.LoggerFactory
 import java.util.concurrent.ConcurrentHashMap
 
 @Command(name = "nebulosa")
@@ -25,9 +27,18 @@ class Nebulosa : Runnable, AutoCloseable {
     @Option(name = ["-p", "--port"])
     private var port = 0
 
+    @Option(name = ["-d", "--debug"])
+    private var debug = false
+
     private lateinit var app: Javalin
 
     override fun run() {
+        if (debug) {
+            with(LoggerFactory.getLogger("nebulosa") as ch.qos.logback.classic.Logger) {
+                level = Level.DEBUG
+            }
+        }
+
         // Run the server.
         app = Javalin.create { config ->
             config.showJavalinBanner = false
@@ -55,16 +66,6 @@ class Nebulosa : Runnable, AutoCloseable {
         app.stop()
     }
 
-    private data object LocationConverter : (String) -> Location? {
-
-        private val CACHED_LOCATION = ConcurrentHashMap<String, Location>(4)
-
-        override fun invoke(value: String): Location? {
-            return if (value.isBlank()) null
-            else CACHED_LOCATION.computeIfAbsent(value) { OBJECT_MAPPER.readValue(value, Location::class.java) }
-        }
-    }
-
     companion object {
 
         @JvmStatic private val LOG = loggerFor<Nebulosa>()
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt b/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
index 9ec0335db..69a993b25 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
@@ -52,19 +52,19 @@ class IERSUpdateTask(
                 .use { it.headers.getDate(Header.LAST_MODIFIED) }
 
             if (modifiedAt != null && "$modifiedAt" == preferenceService.getText(key)) {
-                LOG.info("$url is up to date. modifiedAt={}", modifiedAt)
+                LOG.info("{} is up to date. modifiedAt={}", url, modifiedAt)
                 return
             }
 
             request = request.newBuilder().get().build()
 
-            LOG.info("downloading $url")
+            LOG.debug("downloading {}", url)
 
             httpClient.newCall(request).execute().use {
                 it.body!!.byteStream().transferAndClose(outputStream())
                 modifiedAt = it.headers.getDate(Header.LAST_MODIFIED)
                 preferenceService.putText(key, "$modifiedAt")
-                LOG.info("$url downloaded. modifiedAt={}", modifiedAt)
+                LOG.debug("{} downloaded. modifiedAt={}", url, modifiedAt)
             }
         } catch (e: Throwable) {
             LOG.error("failed to download finals2000A.all", e)
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
index 772ad6eb3..399f15dc5 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
@@ -5,6 +5,7 @@ import io.javalin.http.Context
 import io.javalin.http.bodyAsClass
 import nebulosa.api.connection.ConnectionService
 import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
 
 class AutoFocusController(
     app: Javalin,
@@ -21,7 +22,7 @@ class AutoFocusController(
     private fun start(ctx: Context) {
         val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
         val focuser = connectionService.focuser(ctx.pathParam("focuser")).notNull()
-        val body = ctx.bodyAsClass<AutoFocusRequest>()
+        val body = ctx.bodyAsClass<AutoFocusRequest>().valid()
         autoFocusService.start(camera, focuser, body)
     }
 
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
index fea5d6cfb..cd22137ba 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
@@ -5,8 +5,10 @@ import nebulosa.api.focusers.BacklashCompensationFocuserMoveTask
 import nebulosa.api.focusers.BacklashCompensationMode
 import nebulosa.api.focusers.FocuserEventAware
 import nebulosa.api.message.MessageEvent
+import nebulosa.autofocus.AutoFocus
+import nebulosa.autofocus.AutoFocusListener
+import nebulosa.autofocus.AutoFocusResult
 import nebulosa.curve.fitting.CurvePoint
-import nebulosa.curve.fitting.CurvePoint.Companion.midPoint
 import nebulosa.curve.fitting.HyperbolicFitting
 import nebulosa.curve.fitting.QuadraticFitting
 import nebulosa.curve.fitting.TrendLineFitting
@@ -16,17 +18,13 @@ import nebulosa.indi.device.camera.FrameType
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
 import nebulosa.job.manager.AbstractJob
-import nebulosa.job.manager.LoopTask
 import nebulosa.job.manager.Task
-import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.stardetector.StarDetector
-import nebulosa.stardetector.StarPoint
-import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics
 import java.nio.file.Files
 import java.nio.file.Path
 import java.time.Duration
-import kotlin.math.max
+import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.math.roundToInt
 
 data class AutoFocusJob(
@@ -34,71 +32,68 @@ data class AutoFocusJob(
     @JvmField val camera: Camera,
     @JvmField val focuser: Focuser,
     @JvmField val request: AutoFocusRequest,
-    @JvmField val starDetection: StarDetector<Path>,
-) : AbstractJob(), CameraEventAware, FocuserEventAware {
-
-    data class MeasuredStars(@JvmField val hfd: Double, @JvmField val stdDev: Double) {
-
-        companion object {
-
-            @JvmStatic val EMPTY = MeasuredStars(0.0, 0.0)
-        }
-    }
+    @JvmField val starDetector: StarDetector<Path>,
+) : AbstractJob(), CameraEventAware, FocuserEventAware, AutoFocusListener {
 
     @JvmField val cameraRequest = request.capture.copy(
         savePath = CAPTURE_SAVE_PATH,
         exposureTime = maxOf(request.capture.exposureTime, MIN_EXPOSURE_TIME),
         frameType = FrameType.LIGHT,
         autoSave = false,
-        autoSubFolderMode = AutoSubFolderMode.OFF
+        autoSubFolderMode = AutoSubFolderMode.OFF,
     )
 
     private val cameraExposureTask = CameraExposureTask(this, camera, cameraRequest)
     private val backlashCompensationFocuserMoveTask = BacklashCompensationFocuserMoveTask(this, focuser, 0, request.backlashCompensation)
-    private val initialHFDTask = InitialHFDTask()
     private val reverse = request.backlashCompensation.mode == BacklashCompensationMode.OVERSHOOT && request.backlashCompensation.backlashIn > 0
-    private val offsetSteps = request.initialOffsetSteps
-    private val numberOfSteps = offsetSteps + 1
-    private val obtainFocusPointsTask = ObtainFocusPointsTask(numberOfSteps, offsetSteps, reverse)
-    private val morePointsNeededToTheLeftTask = MorePointsNeededToTheLeftTask()
-    private val morePointsNeededToTheRightTask = MorePointsNeededToTheRightTask()
-    private val computeTrendLineCountTask = ComputeTrendLineCountTask()
-    private val computeFinalFocusPointTask = ComputeFinalFocusPointTask()
-    private val maximumFocusPoints = request.capture.exposureAmount * request.initialOffsetSteps * 10
-    private val measurements = ArrayList<MeasuredStars>(request.capture.exposureAmount)
-    private val focusPoints = ArrayList<CurvePoint>(maximumFocusPoints)
+    private val finished = AtomicBoolean()
 
-    @Volatile private var initialFocusPosition = 0
-    @Volatile private var initialHFD = MeasuredStars.EMPTY
-    @Volatile private var measurementResult = MeasuredStars.EMPTY
-    @Volatile private var numberOfAttempts = 0
+    private val autoFocus = AutoFocus(
+        starDetector, request.capture.exposureAmount,
+        request.initialOffsetSteps, request.stepSize, request.fittingMode,
+        request.rSquaredThreshold, reverse, focuser.maxPosition,
+    )
 
-    @Volatile private var trendLineCurve: TrendLineFitting.Curve? = null
-    @Volatile private var parabolicCurve: QuadraticFitting.Curve? = null
-    @Volatile private var hyperbolicCurve: HyperbolicFitting.Curve? = null
-    @Volatile private var leftCount = 0
-    @Volatile private var rightCount = 0
+    @Volatile private var initialFocusPosition = 0
 
     @JvmField val status = AutoFocusEvent(camera)
 
     init {
-        // Get initial position information, as average of multiple exposures, if configured this way.
-        if (request.rSquaredThreshold <= 0.0) {
-            add(initialHFDTask)
-        }
+        initialFocusPosition = focuser.position
 
-        add(obtainFocusPointsTask)
-        add(computeTrendLineCountTask)
+        val result = autoFocus.determinate(focuser.position)
+        result.handle()
+    }
 
-        LoopTask(this, listOf(morePointsNeededToTheLeftTask, morePointsNeededToTheRightTask, computeTrendLineCountTask)) { _, _ ->
-            (leftCount > 0 || rightCount > 0) && !isDataPointsEnough
-        }.also(::add)
+    private fun AutoFocusResult.handle() {
+        when (this) {
+            AutoFocusResult.Determinate -> return
+            AutoFocusResult.TakeExposure -> {
+                add(cameraExposureTask)
+            }
+            is AutoFocusResult.MoveFocuser -> {
+                backlashCompensationFocuserMoveTask.position = if (relative) focuser.position + position else position
+                add(backlashCompensationFocuserMoveTask)
+            }
+            is AutoFocusResult.Completed -> {
+                status.determinedFocusPoint = determinedFocusPoint
+                status.starHFD = determinedFocusPoint.y
+                status.state = AutoFocusState.FINISHED
+                status.send()
 
-        add(computeFinalFocusPointTask)
-    }
+                movingFocuserToDeterminedFocusPosition(determinedFocusPoint)
+            }
+            is AutoFocusResult.Failed -> {
+                status.determinedFocusPoint = null
+                status.starCount = 0
+                status.starHFD = 0.0
+                status.state = AutoFocusState.FAILED
+                status.send()
 
-    val isDataPointsEnough
-        get() = trendLineCurve != null && (rightCount + focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } >= offsetSteps && leftCount + focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } >= offsetSteps)
+                restoringFocuserToInitialPosition()
+            }
+        }
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
         cameraExposureTask.handleCameraEvent(event)
@@ -109,318 +104,133 @@ data class AutoFocusJob(
     }
 
     override fun beforeStart() {
-        initialFocusPosition = focuser.position
+        LOG.debug("Auto Focus started. reverse={}, request={}, camera={}, focuser={}", reverse, request, camera, focuser)
 
-        LOG.debug { "Auto Focus started. reverse=$reverse, request=$request, camera=$camera, focuser=$focuser" }
+        autoFocus.registerAutoFocusListener(this)
+        finished.set(false)
+
+        camera.snoop(camera.snoopedDevices.filter { it !is Focuser } + focuser)
     }
 
-    override fun canRun(prev: Task?, current: Task): Boolean {
-        if (current === initialHFDTask) {
-            return numberOfAttempts == 0
-        } else if (current === morePointsNeededToTheLeftTask) {
-            return trendLineCurve!!.left.points.size < offsetSteps &&
-                    focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps
-        } else if (current === morePointsNeededToTheRightTask) {
-            return trendLineCurve!!.right.points.size < offsetSteps &&
-                    focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps
+    override fun beforeTask(task: Task) {
+        if (task === backlashCompensationFocuserMoveTask) {
+            status.state = AutoFocusState.MOVING
+            status.send()
+        } else if (task === cameraExposureTask) {
+            status.state = AutoFocusState.EXPOSURING
+            status.send()
         }
-
-        return super.canRun(prev, current)
     }
 
-    override fun accept(event: Any) {
-        when (event) {
-            is CameraExposureEvent -> {
-                status.capture.handleCameraExposureEvent(event)
+    override fun afterTask(task: Task, exception: Throwable?): Boolean {
+        if (exception == null && !finished.get()) {
+            status.state = AutoFocusState.ANALYSING
+            status.send()
 
-                if (event is CameraExposureFinished) {
-                    status.capture.send()
+            while (true) {
+                val result = try {
+                    autoFocus
+                        .determinate(focuser.position)
+                        .also { it.handle() }
+                } catch (e: Throwable) {
+                    LOG.error("auto focus determination failed", e)
 
-                    status.state = AutoFocusState.ANALYSING
+                    status.state = AutoFocusState.FAILED
                     status.send()
 
-                    val detectedStars = starDetection.detect(event.savedPath)
-                    status.starCount = detectedStars.size
-                    LOG.debug("detected {} stars", status.starCount)
-
-                    val measurement = detectedStars.measureDetectedStars()
-                    status.starHFD = measurement.hfd
-                    LOG.debug("HFD measurement: hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
-                    measurements.add(measurement)
+                    restoringFocuserToInitialPosition()
 
-                    status.state = AutoFocusState.ANALYSED
-                } else {
-                    status.state = AutoFocusState.EXPOSURING
+                    return false
                 }
 
-                status.send()
+                if (result !is AutoFocusResult.Determinate) break
             }
-        }
-    }
-
-    private fun evaluateAllMeasurements(): MeasuredStars {
-        if (measurements.isEmpty()) MeasuredStars.EMPTY
-        if (measurements.size == 1) return measurements[0]
-        val descriptiveStatistics = DescriptiveStatistics(measurements.size)
-        measurements.forEach { descriptiveStatistics.addValue(it.hfd) }
-        return MeasuredStars(descriptiveStatistics.mean, descriptiveStatistics.standardDeviation)
-    }
 
-    private fun computeCurveFittings() {
-        with(focusPoints) {
-            trendLineCurve = TrendLineFitting.calculate(this)
-
-            if (size >= 3) {
-                if (request.fittingMode == AutoFocusFittingMode.PARABOLIC || request.fittingMode == AutoFocusFittingMode.TREND_PARABOLIC) {
-                    parabolicCurve = QuadraticFitting.calculate(this)
-                } else if (request.fittingMode == AutoFocusFittingMode.HYPERBOLIC || request.fittingMode == AutoFocusFittingMode.TREND_HYPERBOLIC) {
-                    hyperbolicCurve = HyperbolicFitting.calculate(this)
-                }
+            if (!finished.get()) {
+                status.state = AutoFocusState.ANALYSED
+                status.send()
             }
-
-            val predictedFocusPoint = status.determinedFocusPoint ?: determineFinalFocusPoint()
-            val (minX, minY) = if (isEmpty()) CurvePoint.ZERO else first()
-            val (maxX, maxY) = if (isEmpty()) CurvePoint.ZERO else last()
-            status.chart = AutoFocusEvent.Chart(predictedFocusPoint, minX, minY, maxX, maxY, trendLineCurve, parabolicCurve, hyperbolicCurve)
-
-            status.state = AutoFocusState.CURVE_FITTED
+        } else {
+            status.state = AutoFocusState.FAILED
             status.send()
-            status.chart = null
-        }
-    }
-
-    private fun determineFinalFocusPoint(): CurvePoint? {
-        return when (request.fittingMode) {
-            AutoFocusFittingMode.TRENDLINES -> trendLineCurve?.intersection
-            AutoFocusFittingMode.PARABOLIC -> parabolicCurve?.minimum
-            AutoFocusFittingMode.TREND_PARABOLIC -> parabolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
-            AutoFocusFittingMode.HYPERBOLIC -> hyperbolicCurve?.minimum
-            AutoFocusFittingMode.TREND_HYPERBOLIC -> hyperbolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
-        }
-    }
-
-    private fun validateCalculatedFocusPosition(focusPoint: CurvePoint, initialHFD: Double): Boolean {
-        val threshold = request.rSquaredThreshold
-
-        LOG.info("validating calculated focus position. threshold={}", threshold)
-
-        if (threshold > 0.0) {
-            fun isTrendLineBad() = trendLineCurve?.let { it.left.rSquared < threshold || it.right.rSquared < threshold } != false
-            fun isParabolicBad() = parabolicCurve?.let { it.rSquared < threshold } != false
-            fun isHyperbolicBad() = hyperbolicCurve?.let { it.rSquared < threshold } != false
-
-            val isBad = when (request.fittingMode) {
-                AutoFocusFittingMode.TRENDLINES -> isTrendLineBad()
-                AutoFocusFittingMode.PARABOLIC -> isParabolicBad()
-                AutoFocusFittingMode.TREND_PARABOLIC -> isParabolicBad() || isTrendLineBad()
-                AutoFocusFittingMode.HYPERBOLIC -> isHyperbolicBad()
-                AutoFocusFittingMode.TREND_HYPERBOLIC -> isHyperbolicBad() || isTrendLineBad()
-            }
-
-            if (isBad) {
-                LOG.error("coefficient of determination is below threshold")
-                return false
-            }
-        }
-
-        val min = focusPoints.first().x
-        val max = focusPoints.last().x
-
-        if (focusPoint.x < min || focusPoint.x > max) {
-            LOG.error("determined focus point position is outside of the overall measurement points of the curve")
-            return false
-        }
-
-        if (isCancelled) return false
-
-        MoveFocuserTask(focusPoint.x.roundToInt(), false).run()
-
-        if (threshold <= 0) {
-            TakeExposureTask().run()
-
-            val hfd = measurementResult.hfd
-
-            if (initialHFD != 0.0 && hfd > initialHFD * 1.15) {
-                LOG.warn("New focus point HFR $hfd is significantly worse than original HFR $initialHFD")
-                return false
-            }
-        }
-
-        return true
-    }
 
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun MessageEvent.send() {
-        autoFocusExecutor.accept(this)
-    }
-
-    private inner class InitialHFDTask : Task {
-
-        private val takeExposureTask = TakeExposureTask()
-
-        override fun run() {
-            takeExposureTask.run()
-            initialHFD = measurementResult
+            restoringFocuserToInitialPosition()
         }
-    }
 
-    private inner class TakeExposureTask(private val exposureAmount: Int = cameraRequest.exposureAmount) : Task {
-
-        override fun run() {
-            measurementResult = if (!isCancelled) {
-                measurements.clear()
-
-                status.state = AutoFocusState.EXPOSURING
-                status.send()
-
-                repeat(max(1, exposureAmount)) {
-                    cameraExposureTask.run()
-                }
-
-                evaluateAllMeasurements()
-            } else {
-                MeasuredStars.EMPTY
-            }
-        }
+        return super.afterTask(task, exception)
     }
 
-    private inner class MoveFocuserTask(
-        private val position: Int,
-        private val relative: Boolean,
-    ) : Task {
+    override fun afterFinish() {
+        autoFocus.unregisterAutoFocusListener(this)
 
-        override fun run() {
-            status.state = AutoFocusState.MOVING
+        if (!finished.get()) {
+            status.state = AutoFocusState.IDLE
+            status.capture.state = CameraCaptureState.IDLE
             status.send()
-
-            backlashCompensationFocuserMoveTask.position = if (relative) focuser.position + position else position
-            backlashCompensationFocuserMoveTask.run()
         }
-    }
-
-    private inner class ObtainFocusPointsTask(
-        private val numberOfSteps: Int,
-        private val offset: Int,
-        private val reverse: Boolean,
-    ) : Task {
-
-        private val stepSize = request.stepSize
-        private val direction = if (reverse) -1 else 1
-
-        @JvmField val takeExposureTask = TakeExposureTask()
-        @JvmField val initialOffsetMoveFocuserTask = MoveFocuserTask(direction * offset * stepSize, true)
-        @JvmField val reversedMoveFocuserTask = MoveFocuserTask(direction * -stepSize, true)
-
-        override fun run() {
-            LOG.debug { "retrieving focus points. stepSize=$stepSize, numberOfSteps=$numberOfSteps, offset=$offset, reverse=$reverse" }
-
-            var focusPosition = 0
-
-            if (offset != 0) {
-                initialOffsetMoveFocuserTask.run()
-                focusPosition = focuser.position
-            }
-
-            var remainingSteps = numberOfSteps
-
-            while (!isCancelled && remainingSteps > 0) {
-                val currentFocusPosition = focusPosition
-
-                takeExposureTask.run()
-                val measurement = measurementResult
-
-                if (isCancelled) break
-
-                LOG.debug { "HFD measured after exposures. mean=$measurement" }
-
-                if (remainingSteps-- > 1) {
-                    reversedMoveFocuserTask.run()
-                    focusPosition = focuser.position
-                }
 
-                if (isCancelled) break
+        LOG.debug("Auto Focus finished. camera={}, focuser={}", camera, focuser)
+    }
 
-                // If star measurement is 0, we didn't detect any stars or shapes,
-                // and want this point to be ignored by the fitting as much as possible.
-                if (measurement.hfd == 0.0) {
-                    LOG.warn("No stars detected in step")
-                } else {
-                    val focusPoint = CurvePoint(currentFocusPosition.toDouble(), measurement.hfd, measurement.stdDev)
-                    status.focusPoint = focusPoint
+    override fun accept(event: Any) {
+        when (event) {
+            is CameraExposureEvent -> {
+                status.capture.handleCameraExposureEvent(event)
 
-                    focusPoints.add(focusPoint)
-                    focusPoints.sortBy { it.x }
+                if (!finished.get()) {
+                    if (!isCancelled) {
+                        status.state = if (event is CameraExposureFinished) {
+                            autoFocus.add(event.savedPath)
 
-                    LOG.debug { "focus point added. remainingSteps=$remainingSteps, point=$focusPoint" }
+                            status.capture.send()
+                            AutoFocusState.EXPOSURED
+                        } else {
+                            AutoFocusState.EXPOSURING
+                        }
 
-                    computeCurveFittings()
+                        status.send()
+                    }
+                } else if (event is CameraExposureFinished) {
+                    status.capture.send()
                 }
             }
         }
     }
 
-    private inner class MorePointsNeededToTheLeftTask : Task {
-
-        private val obtainFocusPointsTask = ObtainFocusPointsTask(1, -1, false)
-
-        override fun run() {
-            LOG.info("more data points needed to the left of the minimum")
-
-            val firstX = focusPoints.first().x.roundToInt()
-
-            // Move to the leftmost point - this should never be necessary since we're already there, but just in case
-            if (focuser.position != firstX) {
-                MoveFocuserTask(firstX, false).run()
-            }
-
-            // More points needed to the left.
-            obtainFocusPointsTask.run()
-        }
+    private fun restoringFocuserToInitialPosition() {
+        finished.set(true)
+        backlashCompensationFocuserMoveTask.position = initialFocusPosition
+        backlashCompensationFocuserMoveTask.run()
+        cameraExposureTask.run()
     }
 
-    private inner class MorePointsNeededToTheRightTask : Task {
-
-        private val obtainFocusPointsTask = ObtainFocusPointsTask(1, 1, false)
-
-        override fun run() {
-            LOG.info("more data points needed to the right of the minimum")
-
-            val lastX = focusPoints.last().x.roundToInt()
-
-            // More points needed to the right. Let's get to the rightmost point, and keep going right one point at a time.
-            if (focuser.position != lastX) {
-                MoveFocuserTask(lastX, false).run()
-            }
-
-            // More points needed to the right.
-            obtainFocusPointsTask.run()
-        }
+    private fun movingFocuserToDeterminedFocusPosition(position: CurvePoint) {
+        finished.set(true)
+        backlashCompensationFocuserMoveTask.position = position.x.roundToInt()
+        backlashCompensationFocuserMoveTask.run()
+        cameraExposureTask.run()
     }
 
-    private inner class ComputeTrendLineCountTask : Task {
-
-        override fun run() {
-            leftCount = trendLineCurve?.left?.points?.size ?: 0
-            rightCount = trendLineCurve?.right?.points?.size ?: 0
-        }
+    override fun onStarDetected(count: Int, hfd: Double, stdDev: Double, afterExposures: Boolean) {
+        status.starCount = count
+        status.starHFD = hfd
     }
 
-    private inner class ComputeFinalFocusPointTask : Task {
-
-        override fun run() {
-            val finalFocusPoint = determineFinalFocusPoint()
-
-            if (finalFocusPoint == null || !validateCalculatedFocusPosition(finalFocusPoint, initialHFD.hfd)) {
-                LOG.warn("potentially bad auto-focus. Restoring original focus position")
-                MoveFocuserTask(initialFocusPosition, false).run()
-            } else {
-                status.determinedFocusPoint = finalFocusPoint
-                status.state = AutoFocusState.FINISHED
-                status.send()
+    override fun onCurveFitted(
+        predictedFocusPoint: CurvePoint?,
+        minX: Double, minY: Double,
+        maxX: Double, maxY: Double,
+        trendLine: TrendLineFitting.Curve?, parabolic: QuadraticFitting.Curve?, hyperbolic: HyperbolicFitting.Curve?
+    ) {
+        status.state = AutoFocusState.CURVE_FITTED
+        status.chart = AutoFocusEvent.Chart(predictedFocusPoint, minX, minY, maxX, maxY, trendLine, parabolic, hyperbolic)
+        status.send()
+        status.chart = null
+    }
 
-                LOG.info("Auto Focus completed. x={}, y={}", finalFocusPoint.x, finalFocusPoint.y)
-            }
-        }
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        autoFocusExecutor.accept(this)
     }
 
     companion object {
@@ -428,13 +238,5 @@ data class AutoFocusJob(
         @JvmStatic private val MIN_EXPOSURE_TIME = Duration.ofSeconds(1L)
         @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("af-")
         @JvmStatic private val LOG = loggerFor<AutoFocusJob>()
-
-        @JvmStatic
-        private fun List<StarPoint>.measureDetectedStars(): MeasuredStars {
-            if (isEmpty()) return MeasuredStars.EMPTY
-            val descriptiveStatistics = DescriptiveStatistics(size)
-            forEach { descriptiveStatistics.addValue(it.hfd) }
-            return MeasuredStars(descriptiveStatistics.mean, descriptiveStatistics.standardDeviation)
-        }
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
index 1ba8511da..6d421bbc4 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
@@ -2,7 +2,12 @@ package nebulosa.api.autofocus
 
 import nebulosa.api.cameras.CameraStartCaptureRequest
 import nebulosa.api.focusers.BacklashCompensation
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.positive
+import nebulosa.api.javalin.range
 import nebulosa.api.stardetector.StarDetectionRequest
+import nebulosa.autofocus.AutoFocusFittingMode
 
 data class AutoFocusRequest(
     @JvmField val fittingMode: AutoFocusFittingMode = AutoFocusFittingMode.HYPERBOLIC,
@@ -11,6 +16,14 @@ data class AutoFocusRequest(
     @JvmField val backlashCompensation: BacklashCompensation = BacklashCompensation.EMPTY,
     @JvmField val initialOffsetSteps: Int = 4,
     @JvmField val stepSize: Int = 50,
-    @JvmField val totalNumberOfAttempts: Int = 1,
     @JvmField val starDetector: StarDetectionRequest = StarDetectionRequest.EMPTY,
-)
+) : Validatable {
+
+    override fun validate() {
+        initialOffsetSteps.positive().max(1000)
+        rSquaredThreshold.range(0.0, 1.0)
+        stepSize.positive()
+        capture.validate()
+        starDetector.validate()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
index 2b6a741a1..a73e27807 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
@@ -105,7 +105,7 @@ data class CameraExposureTask(
             }
 
             with(request.makeSavePath(header = header)) {
-                LOG.info("saving FITS image at {}", this)
+                LOG.debug("saving FITS image at {}", this)
                 createParentDirectories()
                 outputPath.moveTo(this, true)
                 job.accept(CameraExposureFinished(job, this@CameraExposureTask, this))
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
index a5ecdb5b6..b4277778e 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
@@ -5,7 +5,6 @@ import nebulosa.indi.device.focuser.FocuserMoveFailed
 import nebulosa.indi.device.focuser.FocuserMovingChanged
 import nebulosa.indi.device.focuser.FocuserPositionChanged
 import nebulosa.job.manager.Job
-import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.util.concurrency.cancellation.CancellationListener
 import nebulosa.util.concurrency.cancellation.CancellationSource
@@ -22,8 +21,8 @@ sealed class AbstractFocuserMoveTask : FocuserTask, CancellationListener {
     override fun handleFocuserEvent(event: FocuserEvent) {
         if (event.device === focuser) {
             when (event) {
-                is FocuserMovingChanged -> if (event.device.moving) moving = true else latch.reset()
-                is FocuserPositionChanged -> if (moving && !event.device.moving) latch.reset()
+                is FocuserMovingChanged -> if (event.device.moving) moving = true else if (moving) latch.reset()
+                // is FocuserPositionChanged -> if (moving && !event.device.moving) latch.reset()
                 is FocuserMoveFailed -> latch.reset()
             }
         }
@@ -35,12 +34,12 @@ sealed class AbstractFocuserMoveTask : FocuserTask, CancellationListener {
 
     override fun run() {
         if (!job.isCancelled && focuser.connected && !focuser.moving && canMove()) {
-            LOG.debug { "Focuser move started. focuser=$focuser" }
+            LOG.debug("Focuser move started. focuser={}", focuser)
             latch.countUp()
             move()
             latch.await()
             moving = false
-            LOG.debug { "Focuser move finished. focuser=$focuser" }
+            LOG.debug("Focuser move finished. focuser={}", focuser)
         }
     }
 
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
index bd84f6fbb..95458f042 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
@@ -4,6 +4,7 @@ import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
 import nebulosa.job.manager.Job
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
 
 /**
  * This task will wrap an absolute backlash [compensation] model around the [focuser].
@@ -38,6 +39,14 @@ data class BacklashCompensationFocuserMoveTask(
         task.handleFocuserEvent(event)
     }
 
+    override fun onCancel(source: CancellationSource) {
+        task.onCancel(source)
+    }
+
+    override fun onPause(paused: Boolean) {
+        task.onPause(paused)
+    }
+
     override fun run() {
         if (!job.isCancelled && focuser.connected && !focuser.moving) {
             val startPosition = focuser.position
@@ -69,9 +78,12 @@ data class BacklashCompensationFocuserMoveTask(
                         } else if (overshoot > focuser.maxPosition) {
                             LOG.warn("overshooting position is above maximum ${focuser.maxPosition}, skipping overshoot")
                         } else {
-                            LOG.info("overshooting from $startPosition to overshoot position $overshoot using a compensation of $backlashCompensation")
+                            LOG.debug(
+                                "overshooting from {} to overshoot position {} using a compensation of {}. Moving back to position {}",
+                                startPosition, overshoot, backlashCompensation, position
+                            )
+
                             moveFocuser(overshoot)
-                            LOG.info("moving back to position $position")
                         }
                     }
 
@@ -82,7 +94,7 @@ data class BacklashCompensationFocuserMoveTask(
                 }
             }
 
-            LOG.info("moving to position {} using {} backlash compensation", newPosition, compensation.mode)
+            LOG.debug("moving to position {} using {} backlash compensation", newPosition, compensation.mode)
 
             moveFocuser(newPosition)
         }
@@ -106,10 +118,10 @@ data class BacklashCompensationFocuserMoveTask(
         val direction = determineMovingDirection(lastPosition, newPosition)
 
         return if (direction == OvershootDirection.IN && lastDirection == OvershootDirection.OUT) {
-            LOG.info("Focuser is reversing direction from outwards to inwards")
+            LOG.debug("Focuser is reversing direction from outwards to inwards")
             -compensation.backlashIn
         } else if (direction == OvershootDirection.OUT && lastDirection === OvershootDirection.IN) {
-            LOG.info("Focuser is reversing direction from inwards to outwards")
+            LOG.debug("Focuser is reversing direction from inwards to outwards")
             compensation.backlashOut
         } else {
             0
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt b/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt
index 18bdfa7e9..1b91e2d98 100644
--- a/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt
@@ -5,9 +5,13 @@ package nebulosa.api.javalin
 import io.javalin.http.Context
 import io.javalin.json.fromJsonString
 import nebulosa.api.atlas.Location
+import java.util.concurrent.ConcurrentHashMap
 
 const val X_LOCATION_HEADER_KEY = "X-Location"
 const val X_IDEMPOTENCY_HEADER_KEY = "X-Idempotency-Key"
 
-inline fun Context.location() = header(X_LOCATION_HEADER_KEY)?.let { this.jsonMapper().fromJsonString<Location>(it) }
+@PublishedApi internal val CACHED_LOCATION = ConcurrentHashMap<String, Location>(4)
+
+inline fun Context.location() =
+    header(X_LOCATION_HEADER_KEY)?.let { value -> CACHED_LOCATION.computeIfAbsent(value) { jsonMapper().fromJsonString<Location>(it) } }
 inline fun Context.idempotencyKey() = header(X_IDEMPOTENCY_HEADER_KEY)
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/DatesAndTimes.kt b/api/src/main/kotlin/nebulosa/api/javalin/Queries.kt
similarity index 99%
rename from api/src/main/kotlin/nebulosa/api/javalin/DatesAndTimes.kt
rename to api/src/main/kotlin/nebulosa/api/javalin/Queries.kt
index 204a8055d..d7dbfb2df 100644
--- a/api/src/main/kotlin/nebulosa/api/javalin/DatesAndTimes.kt
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Queries.kt
@@ -11,4 +11,3 @@ inline fun Context.localDate(): LocalDate = localDateOrNull() ?: LocalDate.now(S
 inline fun Context.localDateOrNull() = queryParam("date")?.let(LocalDate::parse)
 inline fun Context.localTime(): LocalTime = localTimeOrNull() ?: LocalTime.now(SystemClock)
 inline fun Context.localTimeOrNull() = queryParam("time")?.let(LocalTime::parse)
-
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt b/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt
new file mode 100644
index 000000000..d72be300c
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt
@@ -0,0 +1,6 @@
+package nebulosa.api.javalin
+
+fun interface Validatable {
+
+    fun validate()
+}
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt b/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt
index cd1374017..27d493191 100644
--- a/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt
@@ -71,9 +71,4 @@ inline fun <T> Collection<T>.minSize(min: Int) = validate(size >= min) { "size m
 
 // BODY
 
-fun interface Validatable {
-
-    fun validate()
-}
-
-inline fun <T : Validatable> T.valid() = apply { validate() }
+inline fun <T : Validatable> T.valid() = apply(Validatable::validate)
diff --git a/desktop/src/app/autofocus/autofocus.component.html b/desktop/src/app/autofocus/autofocus.component.html
index 38c9fa60c..d4b95892c 100644
--- a/desktop/src/app/autofocus/autofocus.component.html
+++ b/desktop/src/app/autofocus/autofocus.component.html
@@ -99,19 +99,6 @@
 							<label>Initial Offset Steps ({{ request.initialOffsetSteps * request.stepSize }})</label>
 						</p-floatLabel>
 					</div>
-					<div class="col-3 align-items-center">
-						<p-floatLabel>
-							<p-inputNumber
-								styleClass="p-inputtext-sm border-0 max-w-full"
-								[(ngModel)]="request.totalNumberOfAttempts"
-								[showButtons]="true"
-								[min]="1"
-								[max]="10"
-								(ngModelChange)="savePreference()"
-								spinnableNumber />
-							<label>Attempts</label>
-						</p-floatLabel>
-					</div>
 					<div class="col-5 align-items-center">
 						<p-floatLabel class="w-full">
 							<p-dropdown
@@ -144,7 +131,7 @@
 								styleClass="p-inputtext-sm border-0 max-w-full"
 								[(ngModel)]="request.rSquaredThreshold"
 								[showButtons]="true"
-								[min]="0.1"
+								[min]="0"
 								[max]="1"
 								[step]="0.1"
 								(ngModelChange)="savePreference()"
diff --git a/desktop/src/app/autofocus/autofocus.component.ts b/desktop/src/app/autofocus/autofocus.component.ts
index de9c1d9c6..ed0668d68 100644
--- a/desktop/src/app/autofocus/autofocus.component.ts
+++ b/desktop/src/app/autofocus/autofocus.component.ts
@@ -305,22 +305,24 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 
 		electronService.on('AUTO_FOCUS.ELAPSED', (event) => {
 			ngZone.run(() => {
-				this.status = event.state
-				this.running = event.state !== 'FAILED' && event.state !== 'FINISHED'
+				const { state } = event
+
+				this.status = state
+				this.running = state !== 'FAILED' && state !== 'FINISHED' && state !== 'IDLE'
+				this.starCount = event.starCount
+				this.starHFD = event.starHFD
 
 				if (event.capture) {
 					this.cameraExposure.handleCameraCaptureEvent(event.capture, true)
 				}
 
-				if (event.state === 'CURVE_FITTED' && event.focusPoint) {
-					this.focusPoints.push(event.focusPoint)
-				} else if (event.state === 'ANALYSED') {
-					this.starCount = event.starCount
-					this.starHFD = event.starHFD
-				}
-
-				if (event.chart) {
-					this.updateChart(event.chart)
+				if (state === 'CURVE_FITTED') {
+					if (event.focusPoint) {
+						this.focusPoints.push(event.focusPoint)
+					}
+					if (event.chart) {
+						this.updateChart(event.chart)
+					}
 				}
 			})
 		})
@@ -362,6 +364,7 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 
 			const focuser = await this.api.focuser(this.focuser.id)
 			Object.assign(this.focuser, focuser)
+			this.loadPreference()
 		}
 	}
 
@@ -450,8 +453,8 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 	}
 
 	private loadPreference() {
-		if (this.camera?.id) {
-			Object.assign(this.preference, this.preferenceService.autoFocus(this.camera).get())
+		if (this.camera?.id && this.focuser?.id) {
+			Object.assign(this.preference, this.preferenceService.autoFocus(this.camera, this.focuser).get())
 			this.request = this.preference.request
 
 			if (this.camera.connected) {
@@ -461,8 +464,8 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 	}
 
 	protected savePreference() {
-		if (this.camera?.id) {
-			this.preferenceService.autoFocus(this.camera).set(this.preference)
+		if (this.camera?.id && this.focuser?.id) {
+			this.preferenceService.autoFocus(this.camera, this.focuser).set(this.preference)
 		}
 	}
 }
diff --git a/desktop/src/shared/services/preference.service.ts b/desktop/src/shared/services/preference.service.ts
index ea9586ef5..92397db96 100644
--- a/desktop/src/shared/services/preference.service.ts
+++ b/desktop/src/shared/services/preference.service.ts
@@ -103,8 +103,8 @@ export class PreferenceService {
 		return this.create<FlatWizardPreference>(`flatWizard.${camera.name}`, () => structuredClone(DEFAULT_FLAT_WIZARD_PREFERENCE), flatWizardPreferenceWithDefault)
 	}
 
-	autoFocus(camera: Camera) {
-		return this.create<AutoFocusPreference>(`autoFocus.${camera.name}`, () => structuredClone(DEFAULT_AUTO_FOCUS_PREFERENCE), autoFocusPreferenceWithDefault)
+	autoFocus(camera: Camera, focuser: Focuser) {
+		return this.create<AutoFocusPreference>(`autoFocus.${camera.name}.${focuser.name}`, () => structuredClone(DEFAULT_AUTO_FOCUS_PREFERENCE), autoFocusPreferenceWithDefault)
 	}
 
 	sequencer(camera: Camera) {
diff --git a/desktop/src/shared/types/autofocus.type.ts b/desktop/src/shared/types/autofocus.type.ts
index 874f452e5..b1e14d9e7 100644
--- a/desktop/src/shared/types/autofocus.type.ts
+++ b/desktop/src/shared/types/autofocus.type.ts
@@ -22,7 +22,6 @@ export interface AutoFocusRequest {
 	backlashCompensation: BacklashCompensation
 	initialOffsetSteps: number
 	stepSize: number
-	totalNumberOfAttempts: number
 	starDetector: StarDetectionRequest
 }
 
@@ -96,7 +95,6 @@ export const DEFAULT_AUTO_FOCUS_REQUEST: AutoFocusRequest = {
 	rSquaredThreshold: 0.5,
 	initialOffsetSteps: 4,
 	stepSize: 100,
-	totalNumberOfAttempts: 1,
 	backlashCompensation: DEFAULT_BACKLASH_COMPENSATION,
 	starDetector: DEFAULT_STAR_DETECTION_REQUEST,
 }
@@ -120,7 +118,6 @@ export function autoFocusRequestWithDefault(request?: Partial<AutoFocusRequest>,
 	request.rSquaredThreshold ??= source.rSquaredThreshold
 	request.initialOffsetSteps ??= source.initialOffsetSteps
 	request.stepSize ??= source.stepSize
-	request.totalNumberOfAttempts ??= source.totalNumberOfAttempts
 	request.backlashCompensation = backlashCompensationWithDefault(request.backlashCompensation, source.backlashCompensation)
 	request.starDetector = starDetectionRequestWithDefault(request.starDetector, source.starDetector)
 	return request as AutoFocusRequest
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
index 0f01c88ff..7ee0d2750 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
@@ -109,10 +109,10 @@ abstract class ASCOMDevice : Device, Resettable {
                 body
             }
         } catch (e: HttpException) {
-            LOG.error("unexpected response. device=$name", e)
+            LOG.error("unexpected response. device={}", name, e)
         } catch (e: Throwable) {
             sender.fireOnConnectionClosed()
-            LOG.error("unexpected error. device=$name", e)
+            LOG.error("unexpected error. device={}", name, e)
         }
 
         return null
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
index ce85b786f..25a2a0f04 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
@@ -608,7 +608,7 @@ data class ASCOMCamera(
                 LOG.error("failed to read image. device={}, error={}", name, metadata.errorNumber)
                 return
             } else {
-                LOG.info("image read. metadata={}", metadata)
+                LOG.debug("image read. metadata={}", metadata)
             }
 
             val width = metadata.dimension1
diff --git a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
index df0b06bee..4a276e89c 100644
--- a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
+++ b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
@@ -38,7 +38,7 @@ data class AstapStarDetector(
 
         try {
             cmd.start()
-            LOG.info("astap exited. code={}", cmd.get())
+            LOG.debug("astap exited. code={}", cmd.get())
         } catch (e: Throwable) {
             LOG.error("astap failed", e)
             return emptyList()
diff --git a/nebulosa-autofocus/build.gradle.kts b/nebulosa-autofocus/build.gradle.kts
new file mode 100644
index 000000000..6703ef12f
--- /dev/null
+++ b/nebulosa-autofocus/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    kotlin("jvm")
+    id("maven-publish")
+}
+
+dependencies {
+    api(project(":nebulosa-curve-fitting"))
+    api(project(":nebulosa-image"))
+    api(project(":nebulosa-stardetector"))
+    implementation(project(":nebulosa-log"))
+    testImplementation(project(":nebulosa-test"))
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("pluginMaven") {
+            from(components["java"])
+        }
+    }
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt
new file mode 100644
index 000000000..a97294767
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt
@@ -0,0 +1,432 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.curve.fitting.CurvePoint.Companion.midPoint
+import nebulosa.curve.fitting.HyperbolicFitting
+import nebulosa.curve.fitting.QuadraticFitting
+import nebulosa.curve.fitting.TrendLineFitting
+import nebulosa.log.loggerFor
+import nebulosa.stardetector.StarDetector
+import nebulosa.stardetector.StarPoint
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics
+import java.nio.file.Path
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.roundToInt
+
+data class AutoFocus(
+    private val starDetector: StarDetector<Path>,
+    private val exposureAmount: Int = 5,
+    private val initialOffsetSteps: Int = 4,
+    private val stepSize: Int = 50,
+    private val fittingMode: AutoFocusFittingMode = AutoFocusFittingMode.TREND_HYPERBOLIC,
+    private val rSquaredThreshold: Double = 0.0,
+    private val reverse: Boolean = false,
+    private val focusMaxPosition: Int = Int.MAX_VALUE,
+) {
+
+    // TODO: Usar sealed class e remover substate e algumas variáveis como moveFocuserToLeftmostOrRightmost.
+    private enum class State {
+        IDLE,
+        FOCUS_POINTS,
+        EVALUATE_TREND_LINE_POINTS,
+        MORE_POINTS_TO_THE_LEFT,
+        MORE_POINTS_TO_THE_RIGHT,
+        VERIFY_DATA_IS_ENOUGTH,
+        DETERMINATE_FINAL_FOCUS_POINT,
+    }
+
+    private enum class SubState {
+        IDLE,
+        MOVE_FOCUSER,
+        TAKE_EXPOSURE,
+    }
+
+    private val direction = if (reverse) -1 else 1
+    private val numberOfSteps = initialOffsetSteps + 1
+    private val measurements = ArrayList<MeasuredStars>(exposureAmount)
+    private val maximumFocusPoints = exposureAmount * initialOffsetSteps * 10
+    private val focusPoints = ArrayList<CurvePoint>(maximumFocusPoints)
+    private val listeners = ConcurrentHashMap.newKeySet<AutoFocusListener>(1)
+
+    @Volatile private var subState = SubState.IDLE
+    @Volatile private var prevState = State.IDLE
+    @Volatile private var state = State.IDLE
+        private set(value) {
+            prevState = field
+            field = value
+        }
+
+    @Volatile private var measurement = MeasuredStars.EMPTY
+    @Volatile private var exposureCount = 0
+    @Volatile private var remainingSteps = 0
+    @Volatile private var initialFocusPosition = 0
+    @Volatile private var currentFocusPosition = 0
+    @Volatile private var moveFocuserToLeftmostOrRightmost = false
+
+    @Volatile private var trendLineCurve: TrendLineFitting.Curve? = null
+    @Volatile private var parabolicCurve: QuadraticFitting.Curve? = null
+    @Volatile private var hyperbolicCurve: HyperbolicFitting.Curve? = null
+    @Volatile private var leftCount = 0
+    @Volatile private var rightCount = 0
+
+    @Volatile var determinedFocusPoint: CurvePoint? = null
+        private set
+
+    private val isDataPointsEnough
+        get() = trendLineCurve != null && (rightCount + focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } >= initialOffsetSteps && leftCount + focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } >= initialOffsetSteps)
+
+    fun registerAutoFocusListener(listener: AutoFocusListener) {
+        listeners.add(listener)
+    }
+
+    fun unregisterAutoFocusListener(listener: AutoFocusListener) {
+        listeners.remove(listener)
+    }
+
+    fun add(path: Path) {
+        if (exposureCount > 0) {
+            exposureCount--
+            LOG.debug("added. path={}, exposureCount={}", path, exposureCount)
+            measurement = measureStars(path)
+
+            if (exposureCount == 0) {
+                measurement = evaluateAllMeasurements()
+            }
+        }
+    }
+
+    fun reset() {
+        subState = SubState.IDLE
+        state = State.IDLE
+        prevState = State.IDLE
+
+        measurement = MeasuredStars.EMPTY
+        exposureCount = 0
+        remainingSteps = 0
+        initialFocusPosition = 0
+        currentFocusPosition = 0
+        moveFocuserToLeftmostOrRightmost = false
+
+        trendLineCurve = null
+        parabolicCurve = null
+        hyperbolicCurve = null
+        leftCount = 0
+        rightCount = 0
+    }
+
+    fun determinate(focusPosition: Int): AutoFocusResult {
+        LOG.debug("determinate. position={}, state={}, subState={}, prevState={}", focusPosition, state, subState, prevState)
+
+        when (state) {
+            // Estado inicial.
+            State.IDLE -> {
+                // Salva a posição inicial do focalizador, para que possa voltar caso algo dê errado.
+                initialFocusPosition = focusPosition
+
+                // Iniciar a coleta dos pontos de foco.
+                state = State.FOCUS_POINTS
+                remainingSteps = numberOfSteps
+                // Próxima passo é mover o focalizador para a posição mais distante.
+                return moveFocuser(direction * initialOffsetSteps * stepSize, true)
+            }
+            // Estado para obter os pontos de foco e calcular a curva.
+            State.FOCUS_POINTS -> {
+                // Ainda não terminou de capturar todos os pontos de foco necessário.
+                if (remainingSteps > 0) {
+                    // Terminou de mover o focalizador.
+                    if (subState == SubState.MOVE_FOCUSER) {
+                        currentFocusPosition = focusPosition
+                        return takeExposure()
+                    }
+                    // Ainda não terminou a captura.
+                    else if (exposureCount > 0) {
+                        return takeExposure()
+                    }
+                    // Fim da captura.
+                    else if (exposureCount == 0) {
+                        LOG.debug("HFD measured after exposures. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+
+                        computeCurvePoint()
+
+                        // Continua a mover o focalizador.
+                        if (remainingSteps-- > 1) {
+                            return moveFocuser(direction * -stepSize, true)
+                        }
+
+                        state = State.EVALUATE_TREND_LINE_POINTS
+                        subState = SubState.IDLE
+
+                        return AutoFocusResult.Determinate
+                    }
+                }
+            }
+            State.EVALUATE_TREND_LINE_POINTS -> {
+                leftCount = trendLineCurve?.left?.points?.size ?: 0
+                rightCount = trendLineCurve?.right?.points?.size ?: 0
+
+                LOG.debug("trend line evaluated. left={}, right={}", leftCount, rightCount)
+
+                if (leftCount == 0 && rightCount == 0) {
+                    LOG.warn("Not enought spreaded points")
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                // Let's keep moving in, one step at a time, until we have enough left trend points.
+                // Then we can think about moving out to fill in the right trend points.
+                if (trendLineCurve!!.left.points.size < initialOffsetSteps
+                    && focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } < initialOffsetSteps
+                ) {
+                    LOG.debug("more data points needed to the left of the minimum")
+
+                    state = State.MORE_POINTS_TO_THE_LEFT
+
+                    val firstX = focusPoints.first().x.roundToInt()
+
+                    // Move to the leftmost point - this should never be necessary since we're already there, but just in case
+                    if (focusPosition != firstX) {
+                        moveFocuserToLeftmostOrRightmost = true
+                        return moveFocuser(firstX, false)
+                    }
+
+                    // More points needed to the left.
+                    return moveFocuser(direction * -stepSize, true)
+                } else if (trendLineCurve!!.right.points.size < initialOffsetSteps
+                    && focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } < initialOffsetSteps
+                ) {
+                    // Now we can go to the right, if necessary.
+                    LOG.debug("more data points needed to the right of the minimum")
+
+                    state = State.MORE_POINTS_TO_THE_RIGHT
+
+                    val lastX = focusPoints.last().x.roundToInt()
+
+                    // More points needed to the right. Let's get to the rightmost point, and keep going right one point at a time.
+                    if (focusPosition != lastX) {
+                        moveFocuserToLeftmostOrRightmost = true
+                        return moveFocuser(lastX, false)
+                    }
+
+                    // More points needed to the right.
+                    return moveFocuser(direction * stepSize, true)
+                }
+
+                state = State.DETERMINATE_FINAL_FOCUS_POINT
+                return AutoFocusResult.Determinate
+            }
+            State.MORE_POINTS_TO_THE_LEFT -> {
+                // Terminou de mover o focalizador.
+                if (moveFocuserToLeftmostOrRightmost) {
+                    moveFocuserToLeftmostOrRightmost = false
+                    // More points needed to the left.
+                    return moveFocuser(direction * -stepSize, true)
+                } else if (subState == SubState.MOVE_FOCUSER) {
+                    currentFocusPosition = focusPosition
+                    return takeExposure()
+                }
+                // Ainda não terminou a captura.
+                else if (exposureCount > 0) {
+                    return takeExposure()
+                }
+                // Fim da captura.
+                else if (exposureCount == 0) {
+                    state = State.VERIFY_DATA_IS_ENOUGTH
+                    return AutoFocusResult.Determinate
+                }
+            }
+            State.MORE_POINTS_TO_THE_RIGHT -> {
+                // Terminou de mover o focalizador.
+                if (moveFocuserToLeftmostOrRightmost) {
+                    moveFocuserToLeftmostOrRightmost = false
+                    // More points needed to the right.
+                    return moveFocuser(direction * stepSize, true)
+                } else if (subState == SubState.MOVE_FOCUSER) {
+                    currentFocusPosition = focusPosition
+                    return takeExposure()
+                }
+                // Ainda não terminou a captura.
+                else if (exposureCount > 0) {
+                    return takeExposure()
+                }
+                // Fim da captura.
+                else if (exposureCount == 0) {
+                    state = State.VERIFY_DATA_IS_ENOUGTH
+                    return AutoFocusResult.Determinate
+                }
+            }
+            State.VERIFY_DATA_IS_ENOUGTH -> {
+                LOG.debug("HFD measured after exposures. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+
+                computeCurvePoint()
+
+                if (maximumFocusPoints < focusPoints.size) {
+                    // Break out when the maximum limit of focus points is reached
+                    LOG.error("failed to complete. Maximum number of focus points exceeded ({}).", maximumFocusPoints)
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                if (focusPosition <= 0 || focusPosition >= focusMaxPosition) {
+                    // Break out when the focuser hits the min/max position. It can't continue from there.
+                    LOG.error("failed to complete. position reached to min/max")
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                state = if (isDataPointsEnough) {
+                    State.DETERMINATE_FINAL_FOCUS_POINT
+                } else {
+                    subState = SubState.IDLE
+                    State.EVALUATE_TREND_LINE_POINTS
+                }
+
+                return AutoFocusResult.Determinate
+            }
+            State.DETERMINATE_FINAL_FOCUS_POINT -> {
+                val finalFocusPoint = determineFinalFocusPoint()
+
+                return if (finalFocusPoint == null || !validateCalculatedFocusPosition(finalFocusPoint)) {
+                    LOG.warn("potentially bad auto-focus. Restoring original focus position")
+                    AutoFocusResult.Failed(initialFocusPosition)
+                } else {
+                    determinedFocusPoint = finalFocusPoint
+                    LOG.info("Auto Focus completed. x={}, y={}", finalFocusPoint.x, finalFocusPoint.y)
+                    AutoFocusResult.Completed(finalFocusPoint)
+                }
+            }
+        }
+
+        LOG.warn("invalid state. state={}, subState={}, exposureCount={}", state, subState, exposureCount)
+
+        throw IllegalStateException("auto focus has reached an invalid state")
+    }
+
+    private fun moveFocuser(position: Int, relative: Boolean): AutoFocusResult {
+        subState = SubState.MOVE_FOCUSER
+        LOG.debug("moving focuser. position={}, relative={}", position, relative)
+        return AutoFocusResult.MoveFocuser(position, relative)
+    }
+
+    private fun takeExposure(): AutoFocusResult {
+        // Inicia-se a sequência de capturas.
+        if (exposureCount <= 0) {
+            measurements.clear()
+            exposureCount = exposureAmount
+        }
+
+        subState = SubState.TAKE_EXPOSURE
+        LOG.debug("taking exposure. exposureCount={}", exposureCount)
+        return AutoFocusResult.TakeExposure
+    }
+
+    private fun measureStars(path: Path): MeasuredStars {
+        val detectedStars = starDetector.detect(path)
+        LOG.debug("detected {} stars", detectedStars.size)
+        val measurement = detectedStars.measureDetectedStars()
+        LOG.debug("HFD measured. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+        measurements.add(measurement)
+        listeners.forEach { it.onStarDetected(detectedStars.size, measurement.hfd, measurement.stdDev, false) }
+        return measurement
+    }
+
+    private fun evaluateAllMeasurements(): MeasuredStars {
+        if (measurements.isEmpty()) MeasuredStars.EMPTY
+        if (measurements.size == 1) return measurements[0]
+        val descriptiveStatistics = DescriptiveStatistics(measurements.size)
+        measurements.forEach { descriptiveStatistics.addValue(it.hfd) }
+        val stdDev = descriptiveStatistics.standardDeviation
+        val starCount = measurements.sumOf { it.count } / measurements.size
+        listeners.forEach { it.onStarDetected(starCount, descriptiveStatistics.mean, stdDev, true) }
+        return MeasuredStars(starCount, descriptiveStatistics.mean, if (stdDev > 0.0) stdDev else 1.0)
+    }
+
+    private fun computeCurvePoint(): CurvePoint? {
+        return if (measurement.hfd == 0.0) {
+            LOG.warn("no stars detected in step")
+            null
+        } else {
+            val focusPoint = CurvePoint(currentFocusPosition.toDouble(), measurement.hfd, measurement.stdDev)
+            focusPoints.add(focusPoint)
+            focusPoints.sortBy { it.x }
+
+            LOG.debug("focus point added. remainingSteps={}, point={}", remainingSteps, focusPoint)
+
+            computeCurveFittings()
+
+            focusPoint
+        }
+    }
+
+    private fun computeCurveFittings() {
+        with(focusPoints) {
+            trendLineCurve = TrendLineFitting.calculate(this)
+
+            if (size >= 3) {
+                if (fittingMode == AutoFocusFittingMode.PARABOLIC || fittingMode == AutoFocusFittingMode.TREND_PARABOLIC) {
+                    parabolicCurve = QuadraticFitting.calculate(this)
+                } else if (fittingMode == AutoFocusFittingMode.HYPERBOLIC || fittingMode == AutoFocusFittingMode.TREND_HYPERBOLIC) {
+                    hyperbolicCurve = HyperbolicFitting.calculate(this)
+                }
+            }
+
+            val predictedFocusPoint = determinedFocusPoint ?: determineFinalFocusPoint()
+            val (minX, minY) = if (isEmpty()) CurvePoint.ZERO else first()
+            val (maxX, maxY) = if (isEmpty()) CurvePoint.ZERO else last()
+
+            listeners.forEach { it.onCurveFitted(predictedFocusPoint, minX, minY, maxX, maxY, trendLineCurve, parabolicCurve, hyperbolicCurve) }
+        }
+    }
+
+    private fun determineFinalFocusPoint(): CurvePoint? {
+        return when (fittingMode) {
+            AutoFocusFittingMode.TRENDLINES -> trendLineCurve?.intersection
+            AutoFocusFittingMode.PARABOLIC -> parabolicCurve?.minimum
+            AutoFocusFittingMode.TREND_PARABOLIC -> parabolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
+            AutoFocusFittingMode.HYPERBOLIC -> hyperbolicCurve?.minimum
+            AutoFocusFittingMode.TREND_HYPERBOLIC -> hyperbolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
+        }
+    }
+
+    private fun validateCalculatedFocusPosition(focusPoint: CurvePoint): Boolean {
+        LOG.debug("validating calculated focus position. threshold={}, x={}, y={}", rSquaredThreshold, focusPoint.x, focusPoint.y)
+
+        if (rSquaredThreshold > 0.0) {
+            fun isTrendLineBad() = trendLineCurve?.let { it.left.rSquared < rSquaredThreshold || it.right.rSquared < rSquaredThreshold } != false
+            fun isParabolicBad() = parabolicCurve?.let { it.rSquared < rSquaredThreshold } != false
+            fun isHyperbolicBad() = hyperbolicCurve?.let { it.rSquared < rSquaredThreshold } != false
+
+            val isBad = when (fittingMode) {
+                AutoFocusFittingMode.TRENDLINES -> isTrendLineBad()
+                AutoFocusFittingMode.PARABOLIC -> isParabolicBad()
+                AutoFocusFittingMode.TREND_PARABOLIC -> isParabolicBad() || isTrendLineBad()
+                AutoFocusFittingMode.HYPERBOLIC -> isHyperbolicBad()
+                AutoFocusFittingMode.TREND_HYPERBOLIC -> isHyperbolicBad() || isTrendLineBad()
+            }
+
+            if (isBad) {
+                LOG.error("coefficient of determination is below threshold")
+                return false
+            }
+        }
+
+        val min = focusPoints.first().x
+        val max = focusPoints.last().x
+
+        if (focusPoint.x < min || focusPoint.x > max) {
+            LOG.error("determined focus point position is outside of the overall measurement points of the curve")
+            return false
+        }
+
+        return true
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<AutoFocus>()
+
+        private fun List<StarPoint>.measureDetectedStars(): MeasuredStars {
+            if (isEmpty()) return MeasuredStars.EMPTY
+            val descriptiveStatistics = DescriptiveStatistics(size)
+            forEach { descriptiveStatistics.addValue(it.hfd) }
+            val stdDev = descriptiveStatistics.standardDeviation
+            return MeasuredStars(size, descriptiveStatistics.mean, if (stdDev > 0.0) stdDev else 1.0)
+        }
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
similarity index 80%
rename from api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt
rename to nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
index ea43d243a..9eeb12f53 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
@@ -1,4 +1,4 @@
-package nebulosa.api.autofocus
+package nebulosa.autofocus
 
 enum class AutoFocusFittingMode {
     TRENDLINES,
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt
new file mode 100644
index 000000000..0dc419304
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt
@@ -0,0 +1,16 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.curve.fitting.HyperbolicFitting
+import nebulosa.curve.fitting.QuadraticFitting
+import nebulosa.curve.fitting.TrendLineFitting
+
+interface AutoFocusListener {
+
+    fun onStarDetected(count: Int, hfd: Double, stdDev: Double, afterExposures: Boolean)
+
+    fun onCurveFitted(
+        predictedFocusPoint: CurvePoint?, minX: Double, minY: Double, maxX: Double, maxY: Double,
+        trendLine: TrendLineFitting.Curve?, parabolic: QuadraticFitting.Curve?, hyperbolic: HyperbolicFitting.Curve?
+    )
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt
new file mode 100644
index 000000000..b722d4791
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt
@@ -0,0 +1,31 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+
+sealed interface AutoFocusResult {
+
+    /**
+     * Should take a exposure.
+     */
+    data object TakeExposure : AutoFocusResult
+
+    /**
+     * Should move the focuser to [position], [relative] or not.
+     */
+    data class MoveFocuser(@JvmField val position: Int, @JvmField val relative: Boolean) : AutoFocusResult
+
+    /**
+     * Should call [AutoFocus.determinate] method again.
+     */
+    data object Determinate : AutoFocusResult
+
+    /**
+     * Auto Focus can not be determinated because it failed.
+     */
+    data class Failed(@JvmField val initialFocusPosition: Int) : AutoFocusResult
+
+    /**
+     * Auto Focus finished with success.
+     */
+    data class Completed(@JvmField val determinedFocusPoint: CurvePoint) : AutoFocusResult
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt
new file mode 100644
index 000000000..f0f2bfcb3
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt
@@ -0,0 +1,13 @@
+package nebulosa.autofocus
+
+data class MeasuredStars(
+    @JvmField val count: Int,
+    @JvmField val hfd: Double,
+    @JvmField val stdDev: Double,
+) {
+
+    companion object {
+
+        @JvmStatic val EMPTY = MeasuredStars(0, 0.0, 0.0)
+    }
+}
diff --git a/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt b/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt
new file mode 100644
index 000000000..399bb8c5c
--- /dev/null
+++ b/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt
@@ -0,0 +1,115 @@
+import io.kotest.matchers.ints.shouldBeExactly
+import io.kotest.matchers.nulls.shouldNotBeNull
+import nebulosa.autofocus.AutoFocus
+import nebulosa.autofocus.AutoFocusFittingMode
+import nebulosa.autofocus.AutoFocusFittingMode.*
+import nebulosa.autofocus.AutoFocusResult
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.stardetector.StarDetector
+import nebulosa.stardetector.StarPoint
+import nebulosa.test.*
+import org.junit.jupiter.api.Test
+import java.nio.file.Path
+import kotlin.math.cosh
+import kotlin.math.ln
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+class AutoFocusTest : AbstractTest() {
+
+    @Test
+    fun trendHyperbolic() {
+        executeAutoFocus().shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+        executeAutoFocus(700).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200).shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+        executeAutoFocus(exposureAmount = 3).shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+    }
+
+    @Test
+    fun trendParabolic() {
+        executeAutoFocus(fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 807
+        executeAutoFocus(700, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 805
+        executeAutoFocus(exposureAmount = 3, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 807
+    }
+
+    @Test
+    fun trendlines() {
+        executeAutoFocus(fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(700, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(exposureAmount = 3, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+    }
+
+    @Test
+    fun hyperbolic() {
+        executeAutoFocus(fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 796
+        executeAutoFocus(700, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 795
+        executeAutoFocus(exposureAmount = 3, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 796
+    }
+
+    @Test
+    fun parabolic() {
+        executeAutoFocus(fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 814
+        executeAutoFocus(700, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 809
+        executeAutoFocus(exposureAmount = 3, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 814
+    }
+
+    private data class DetectedStar(
+        override val hfd: Double,
+        override val x: Double = 0.0, override val y: Double = 0.0,
+        override val snr: Double = 0.0, override val flux: Double = 0.0,
+    ) : StarPoint
+
+    private data class HyperbolicStarDetector(private val offset: Int = 8) : StarDetector<Path> {
+
+        override fun detect(input: Path): List<StarPoint> {
+            val index = STAR_FOCUS_LIST.indexOf(input)
+            val hfd = max(1.0, ln(cosh(((index - offset) * 2).toDouble())))
+            return listOf(DetectedStar(hfd))
+        }
+    }
+
+    companion object {
+
+        @JvmStatic val STAR_FOCUS_LIST = listOf(
+            STAR_FOCUS_1, STAR_FOCUS_2, STAR_FOCUS_3, STAR_FOCUS_4, STAR_FOCUS_5,
+            STAR_FOCUS_6, STAR_FOCUS_7, STAR_FOCUS_8, STAR_FOCUS_9, STAR_FOCUS_10,
+            STAR_FOCUS_11, STAR_FOCUS_12, STAR_FOCUS_13, STAR_FOCUS_14, STAR_FOCUS_15,
+            STAR_FOCUS_16, STAR_FOCUS_17,
+        )
+
+        @JvmStatic
+        private fun executeAutoFocus(
+            initialFocusPosition: Int = 1000,
+            exposureAmount: Int = 1,
+            initialOffsetSteps: Int = 4,
+            stepSize: Int = 100,
+            fittingMode: AutoFocusFittingMode = TREND_HYPERBOLIC,
+            rSquaredThreshold: Double = 0.0,
+            reverse: Boolean = false,
+        ): CurvePoint? {
+            val autoFocus =
+                AutoFocus(HyperbolicStarDetector(), exposureAmount, initialOffsetSteps, stepSize, fittingMode, rSquaredThreshold, reverse, 16000)
+
+            var focusPosition = initialFocusPosition
+            var focusPoint: CurvePoint? = null
+
+            while (focusPoint == null) {
+                when (val result = autoFocus.determinate(focusPosition)) {
+                    AutoFocusResult.Determinate -> continue
+                    is AutoFocusResult.MoveFocuser -> focusPosition = if (result.relative) focusPosition + result.position else result.position
+                    AutoFocusResult.TakeExposure -> autoFocus.add(STAR_FOCUS_LIST[focusPosition / 100])
+                    is AutoFocusResult.Completed -> focusPoint = result.determinedFocusPoint
+                    is AutoFocusResult.Failed -> break
+                }
+
+                // Thread.sleep(100)
+            }
+
+            return focusPoint
+        }
+    }
+}
diff --git a/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt b/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
index 6be7004d0..464488576 100644
--- a/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
+++ b/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
@@ -145,7 +145,7 @@ open class FitsHeader : AbstractHeader {
                     return true
                 }
 
-                LOG.warn("[${key.key}] with unexpected value type. Expected ${key.valueType}, got $type")
+                LOG.debug("[{}] with unexpected value type. Expected {}, got {}", key.key, key.valueType, type)
 
                 return false
             }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 8cad64316..9bf125d99 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -56,6 +56,7 @@ include(":nebulosa-astap")
 include(":nebulosa-astrobin-api")
 include(":nebulosa-astrometrynet")
 include(":nebulosa-astrometrynet-jna")
+include(":nebulosa-autofocus")
 include(":nebulosa-constants")
 include(":nebulosa-curve-fitting")
 include(":nebulosa-erfa")