staticvarLearn
/

Android

Jetpack Compose Internals

A staged, source-pinned path from compiler-generated protocol calls through composition storage, snapshot state, invalidation, scheduling, effects, moving and reusing composition, change application to the UI tree, and evidence-led tooling, multiplatform, performance, and evolution analysis.

LevelAdvancedTimeAll 11 chapters: 3 hours 23 minutes–4 hours 22 minutesChapters11Lessons46
Start learning →

What you’ll learn

By the end of this course

Evidence labels glossary → How to read claim freshness and evidence, not public API stability.

Course outline

Chapters & lessons

01

What system did Compose actually build?

Six short lessons move from compiler protocol to composition memory, applied changes, UI nodes, and source inspection.

  1. The compiler/runtime/node pipelineDraw the five boundaries between a composable call and a target UI node.3 min →
  2. Reading Compose source as evidenceUse declarations, producers, consumers, tests, and history to bound an internals claim.4 min →
  3. Composition storage is runtime memorySeparate groups and slots used for recomposition from the UI tree they help update.3 min →
  4. Composition calculates, then applies changesFollow pending operations from composition calculation to an applier-owned target tree.3 min →
  5. From a node operation to LayoutNodeConnect compiler-facing node operations to the Compose UI tree without equating every composable with a node.3 min →
  6. Follow one state change through the pipelineUse a controlled composition to distinguish invalidation, recalculation, and applied node updates.3 min →
02

The compiler/runtime protocol

Read the hidden parameters, groups, restart callbacks, and identity signals that connect composable source to the runtime.

  1. What `@Composable` changesBuild the mental model for a composable function type and its implicit composer context.4 min →
  2. The hidden `Composer` and mask parametersRead changed masks and default masks without mistaking their bit layout for a public contract.4 min →
  3. Transformed calls and composable function referencesFollow ordinary-looking calls and callable references through compiler adaptation and compatibility checks.4 min →
  4. Groups, restart scopes, and source keysConnect control-flow boundaries to restart callbacks, durable keys, and historical group elision.4 min →
  5. Replace, movable, and reusable groupsDistinguish control-flow replacement, state-preserving movement, and node reuse in the runtime protocol.3 min →
04

Identity, keys, remember, and lifecycle

Learn how Compose matches groups, caches values, and reports committed, forgotten, and abandoned objects.

  1. Positional identity and explicit key groupsPredict how Compose matches groups when control flow and repeated calls change.3 min →
  2. Sibling reorder, `joinKey`, and moving stateExplain why keyed siblings move remembered state and how compound data keys are represented.3 min →
  3. `remember` is a slot cacheTrace a remember call from key comparison to cached value, calculation, and slot update.3 min →
  4. Remembered, forgotten, and abandoned objectsClassify RememberObserver callbacks without confusing calculation, commitment, and removal.4 min →
  5. Apply success, failure, and event dispatchFollow RememberManager and RememberEventDispatcher across successful, failed, and abandoned composition.3 min →
05

Snapshots and observable state

Follow snapshot records from readable values through isolated writes, apply conflicts, observation, and derived state.

  1. A state object is a record chainExplain how one snapshot-aware state object stores versioned records and selects a readable value.4 min →
  2. Snapshots isolate valuesDistinguish global, read-only, mutable, and nested snapshots by what they can see and when changes become visible.4 min →
  3. Apply is a commit attemptTrace successful and conflicting snapshot applies without confusing consistency with recomposition scheduling.4 min →
  4. Mutation policies decide equivalenceCompare structural, referential, never-equal, and custom merge policies at the snapshot state boundary.4 min →
  5. Reads become observation edgesMap snapshot reads to composition scopes and SnapshotStateObserver callbacks without jumping ahead to frame scheduling.4 min →
  6. `derivedStateOf` tracks dependencies and valuesExplain how derived state caches a result, records dependencies, and compares the result seen by an observer.4 min →
06

Invalidation, recomposition, and skipping

Follow a state write to an observed scope, then read the compiler and runtime conditions that permit skipping.

  1. A state write targets observed scopesTrace snapshot notification into Recomposer, CompositionImpl, and a RecomposeScopeImpl without confusing invalidation with execution.3 min →
  2. Invalidation can be conditional or imminentInterpret InvalidationResult and see why a derived-state change or an active composition can alter the invalidation path.3 min →
  3. Stability becomes comparison metadataRead compiler stability inference, stable versus immutable promises, changed comparisons, and dirty masks without treating bit layouts as API.3 min →
  4. Skipping is a decision, not a guaranteeConnect shouldExecute and skipToGroupEnd to strong skipping, current defaults, and the reasons a restartable function still executes.3 min →
07

Scheduling and the Recomposer

Follow invalidation into frame-aligned work, then separate removed concurrent recomposition history from current pausable composition and serialized application.

  1. The recomposition loop and frame clockTrace snapshot invalidation through a frame, then separate recomposition from change application.3 min →
  2. Historical concurrent recomposition and current pausable compositionVerify the removed concurrent runner, then inspect current pausable composition and its serialized application boundary.4 min →
08

Effects and retained lifetimes

Trace composition effects from successful apply through coroutine ownership, then separate remembered, retained, saved, and process lifetimes.

  1. Side effects run after a successful applyTrace SideEffect and DisposableEffect from composition recording to apply-phase callbacks and remembered lifecycle.3 min →
  2. LaunchedEffect belongs to a keyed composition scopeTrace coroutine context, cancellation, rememberCoroutineScope ownership, and effect keys as lifetime identity.4 min →
  3. Remember, retain, and saved state are different lifetimesSeparate slot memory, in-memory transient retention, saved-state restoration, and process lifetime.5 min →
  4. Retention has its own store and observer lifecycleFollow RetainedValuesStore ownership, RetainObserver callbacks, RetainedEffect retirement, and DoNotRetain leak protection.4 min →
09

Moving, reusing, and nesting composition

Trace movable identity, reusable nodes, nested composition ownership, and SubcomposeLayout slot reuse without treating them as interchangeable.

  1. Movable content carries identity across locationsTrace how movableContentOf extracts remembered state, nodes, and invalidations, then inserts them at a new call site.4 min →
  2. Reusable composition changes the node lifecycleDistinguish node recycling from movable identity and follow reuse, deactivation, and release callbacks.4 min →
  3. CompositionContext makes nesting one logical treeFollow SubcomposeLayout from its parent context to child compositions created during measure.4 min →
  4. SubcomposeLayout turns slots into a reuse poolRead the active, reusable, and precomposed child ranges, then follow paused precomposition as a handle workflow.4 min →
10

From changes to UI behavior

Follow runtime change operations into Compose UI nodes, modifier nodes, measurement, layout, drawing, and pointer hit paths.

  1. Applier operations are a tree protocolRead traversal, insertion, removal, movement, clearing, and change-list application as one target-tree protocol.3 min →
  2. `ComposeNode` crosses into `LayoutNode`Follow createNode, useNode, updater blocks, and the Android UiApplier into the concrete Compose UI tree.4 min →
  3. A node update fans out into UI workTrace modifier-chain updates into targeted requests for remeasurement, relayout, and redraw.4 min →
  4. One state change reaches pixels and hit pathsTrace one observed state write through recomposition, node application, measurement, placement, drawing, and pointer hit-path dispatch.4 min →
11

Tooling, multiplatform behavior, performance, and evolution

Update a Compose internals model in order: pinned implementation, tests/generated evidence, history, release notes, design docs for historical intent that may lag current code, then roadmap intent only.

  1. Source information becomes tooling dataMap compiler-emitted source strings and markers to composition groups, diagnostic traces, tracer events, and scope observers.4 min →
  2. Multiplatform behavior has boundariesSeparate common runtime semantics from target-specific synchronization, atomics, thread identity, and frame-clock integration.4 min →
  3. Benchmark evidence is workload-shapedMatch Compose runtime benchmark workloads to costs, metrics, controls, and confounders without claiming universal percentages.4 min →
  4. Evolution is a reading workflowUpdate a Compose internals model in order: pinned implementation, tests/generated evidence, history, release notes, design docs, then roadmap intent.4 min →