Stuttering in Development — What It Is, Causes, and Optimization Methods

What Does “Stuttering” Mean in Mobile Development

Stuttering is an informal term users employ to describe subjectively slow app performance. Unlike a lag, which manifests as a constant delay, stuttering consists of irregular freezes: the app may work perfectly for several seconds and then “think” for 1–3 seconds.

Technical Description of the Phenomenon

From a profiling perspective, stuttering manifests as a series of missed frames (jank) with peak delays exceeding 100 ms. On an FPS graph, this looks like sharp drops: 60 → 20 → 55 → 10 frames per second. Unlike a lag with uniformly low FPS, stuttering has pronounced variability.

User Perception

When an app stutters, the user cannot understand the logic of slowdowns: the screen may scroll smoothly and then suddenly stop for a second. This causes frustration and reduces trust in the app. According to Google, 53% of users leave a site or app if loading takes more than 3 seconds.

Causes of Sudden Slowdowns in Apps

The intermittent nature of stuttering indicates that the problem is caused by event-driven factors rather than constant overload. Let’s examine typical scenarios.

GC Pauses During Object Allocation

On Android, in the ART runtime, garbage collection stops all app threads. If the code creates many temporary objects — for example, creating a new String via concatenation on every onBindViewHolder call — GC runs more frequently. A pause can last 5–50 ms depending on heap size and object generation. The user perceives this as sudden “thoughtfulness.”

Synchronous SQL Queries on the UI Thread

Room on Android and Core Data on iOS support asynchronous queries, but developers often call getValue() or execute queries via runBlocking for simplicity. A heavy SELECT with joins on a 10,000-row table can take 200–500 ms, completely blocking the UI during that time.

Image Decoding Without Downscale

Loading a camera image (12 MP, 4000x3000 px) without scaling takes up to 200 ms for Bitmap decoding. If images are loaded asynchronously but without a bounded thread pool, running 5–6 decodes simultaneously can overload the CPU, causing migrating slowdowns.

• Android — string concatenation in loops, object creation in hot paths, Bitmap without inSampleSize
• iOS — autorelease pools with many objects, imageWithContentsOfFile without scaling, synchronous URLSession
• Cross-platform — JSON parsing on the UI thread, loading data on the main thread while waiting for server response

How to Diagnose Freezes on Android and iOS

Diagnosing intermittent slowdowns is harder than diagnosing constant lags because the problem may not reproduce on every run. Statistics collection over a long period is required.

Memory Profiler with GC Event Recording

Android Studio Memory Profiler shows not only memory usage but also GC events: frequency, type (Concurrent, Full), duration. If GC occurs more than once every 5 seconds in an idle state — that is a sign of excessive allocation. Taking a heap dump at the moment of stuttering reveals which objects are occupying memory.

Xcode Instruments with Allocation Tracking

On iOS, use the Allocations template in Instruments to track object creation and deallocation. Enable Generations — they allow you to take heap snapshots between actions and see which objects remain in memory. Persistent objects that are not deallocated are a source of memory accumulation and subsequent pauses.

JankStats API on Android

JankStats is an Android library that collects missed frame metrics in real time. It ties each jank to the current scenario (e.g., “list scrolling”, “screen opening”), making it possible to understand which specific action triggers stuttering.

Example of integrating JankStats for tracking freezes on Android:

class MainActivity : AppCompatActivity() {
    private lateinit var jankStats: JankStats

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        jankStats = JankStats.create(this.window.decorView) { frameData ->
            if (frameData.isJank()) {
                Log.w("Jank", "Duration=${frameData.durationMs}ms")
            }
        }
    }
}

Methods for Eliminating Slow Performance

Eliminating stuttering requires targeted work on each cause. There is no universal solution — analysis of specific performance profiles is needed.

Implementing Pagination via Paging 3

If a list contains 1000+ items and all are loaded at once — that is guaranteed stuttering. Paging 3 on Android and NSFetchedResultsController on iOS load data in portions as the user scrolls. The user sees only the first 10–20 items; the rest are loaded in the background.

Optimizing SQL Queries and Indexes

Room allows profiling queries via the Inspection Tool in Android Studio: execution time, number of returned rows, and query plan are visible. Adding indexes on WHERE and ORDER BY columns can reduce query time from 300 ms to 5 ms. On iOS, a similar check is performed by Core Data Profiler in Instruments.

Offloading Tasks to WorkManager

Background syncs, file downloads, data processing — all of this should be executed via WorkManager (Android) or Background Tasks (iOS). If synchronization runs on the UI thread, the app will stutter during execution. WorkManager guarantees execution on a background thread with battery and network state awareness.

Example of background synchronization via WorkManager on Android:

class SyncWorker(context: Context, params: WorkerParameters)
    : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            Log.d("Sync", "Syncing data in background thread")
            syncData()
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

Preventing Stuttering at the Development Stage

Stuttering can be prevented at the coding stage by following the principles of efficient memory and thread management.

Baseline Profiles for AOT Compilation

Baseline Profiles are a list of classes and methods that Android compiles ahead of time (AOT) rather than JIT. Without a profile, each new screen is compiled on first opening, causing a 100–500 ms delay. Prepare a Baseline Profile for key screens and enable generation in Gradle via the baseline-profile-gradle-plugin.

Minimizing Allocations in Hot Paths

A hot path is code that executes on every frame: onBindViewHolder, draw, layoutSubviews. Avoid creating objects in these methods: use object pools, StringBuilder instead of concatenation, cache formatted strings and formatters. Every extra allocation brings the next GC closer.

Profiling via Baseline Profiles in CI

Add Macrobenchmark to your CI pipeline with a list scrolling and screen opening scenario. Set a threshold: the 99th percentile frame time must not exceed 16 ms. If the threshold is exceeded — the build is rejected until optimization.

• Android — Baseline Profiles, Macrobenchmark, JankStats, StrictMode with penaltyDeath
• iOS — MetricKit, os_signpost, XCTMetric, Main Thread Checker in Debug scheme
• General approach — regular profiling, code reviews focused on allocations in hot paths