ARC Retain Cycle Lab | mysimulator.uk

Allocate

Wire References

From (holds the reference)

To (the referenced object)

Demos

Live Heap State

Alive objects

Total retain count

Leaked (unreachable)

Deallocated (session)

Alive, reachable from a root Leaked — retain > 0 but unreachable Root-held (stack variable)

How it works

This models Automatic Reference Counting (ARC), the memory strategy iOS uses. Every heap object carries a retain count RC — the number of strong references currently pointing at it:

RC(obj) = [held by a root variable? 1 : 0]
        + count of alive objects with a strong
          reference pointing at obj

dealloc(obj)  the instant RC(obj) reaches 0 — synchronously,
              which then releases obj's own strong
              references, decrementing their targets
              (this can cascade)

A weak reference (dashed edge here) points at an object without incrementing its RC — it does not keep the object alive, and reads as absent once the object is freed.

The retain-cycle failure mode: if A holds a strong reference to B and B holds a strong reference back to A, then releasing every root that pointed into the pair leaves RC(A) = RC(B) = 1 forever — each is kept alive purely by the other. Neither is reachable by walking outward from any live root, so the app can never reach them again, yet ARC never frees them: a permanent leak. Breaking one edge of the cycle into a weak reference removes that mutual RC contribution, so releasing the roots lets both objects' RC reach 0 and they deallocate normally.

The "Leaked" counter below is computed by a reachability scan: BFS outward along strong edges from every root-held object. Any alive object the scan never reaches is leaked, no matter what its RC says.

Click an object in the scene to select it in "From". Strong = solid arrow. Weak = dashed.

⚠ Couldn't load the 3D engineThree.js failed to load from the CDN. Check your connection and reload.