setNeedsDisplay(): method essence and redrawing mechanism in iOS

What is setNeedsDisplay()

setNeedsDisplay() is a UIView method that signals to the system that the view's content is outdated and needs re-rendering. The method takes no parameters and returns void. After the call, the view is marked as dirty, and in the nearest drawing cycle the system calls draw(_:) for this view.

The key feature is asynchronicity. Multiple consecutive calls to setNeedsDisplay() for the same view will not result in multiple draw(_:) calls — the system combines them into a single operation. This is critically important for performance: if a view property changes multiple times per frame, draw(_:) is called only once.

How deferred redrawing works

The deferred redrawing mechanism is based on the UIKit rendering cycle. When setNeedsDisplay() is called, the system sets the internal flag layer.needsDisplay to true. At the end of the current run loop, the system iterates through all dirty layers and calls draw(_:) for each one.

Run loop and rendering steps

The UIKit run loop includes an update phase during which dirty views are processed. In this phase, layoutSubviews() is called if needed, then draw(_:) for all marked views. After drawing is complete, the result is passed to the GPU through Core Animation for compositing.

class ProgressView: UIView {
    var progress: CGFloat = 0 {
        didSet {
            setNeedsDisplay()
        }
    }

    override func draw(_ rect: CGRect) {
        super.draw(rect)
        guard let ctx = UIGraphicsGetCurrentContext() else { return }

        // Background
        ctx.setFillColor(UIColor.lightGray.cgColor)
        ctx.fill(rect)

        // Progress bar
        let fillRect = CGRect(x: rect.minX, y: rect.minY,
                              width: rect.width * progress, height: rect.height)
        ctx.setFillColor(UIColor.systemGreen.cgColor)
        ctx.fill(fillRect)
    }
}

In this example, progressView updates progress, and each setter automatically calls setNeedsDisplay(). The system waits for the end of the run loop and calls draw(_:) with the actual progress value. If progress changes three times per frame, draw(_:) executes only once — with the last value.

setNeedsDisplay() vs setNeedsDisplay(_:)

The setNeedsDisplay(_:) method takes a rect parameter of type CGRect, limiting the redraw area. This allows redrawing only the changed part of the view, rather than the entire view. The performance difference becomes noticeable when working with large views where changes affect a small area.

For complex graphics, it is recommended to draw the entire scene in an offscreen context first, and then call setNeedsDisplay(_:) only for the changed area. This is a standard technique in drawing applications and graphic editors on iOS.

displayIfNeeded() vs setNeedsDisplay()

displayIfNeeded() is a synchronous method that immediately triggers redrawing of all dirty views in the hierarchy, without waiting for the end of the run loop. Unlike setNeedsDisplay(), which only sets a flag, displayIfNeeded() forces immediate execution of draw(_:).

Apple recommends using displayIfNeeded() only in extreme cases when the drawing result is needed immediately — for example, before taking a screenshot or during synchronous image generation for UIGraphicsImageRenderer. In normal scenarios, the asynchronous model through setNeedsDisplay() is preferable as it does not block the main thread.

    // Asynchronous — recommended
someView.setNeedsDisplay()

    // Synchronous — only when necessary
someView.setNeedsDisplay()
someView.displayIfNeeded() // draw(_:) called immediately

Calling displayIfNeeded() without a preceding setNeedsDisplay() will have no effect — the method only processes views already marked as dirty. If no view needs redrawing, displayIfNeeded() completes without calling draw(_:).

Optimizing setNeedsDisplay() calls

Frequent calls to setNeedsDisplay() can degrade performance, especially during animation. Let's look at the main optimization strategies.

Batching changes through a model

Instead of calling setNeedsDisplay() on every change of an individual property, accumulate changes and call the method once after applying all updates. For example, when changing the color, size, and position of an element — call setNeedsDisplay() once after setting all properties.

Using CALayer for animatable properties

If a property can be animated through CALayer (backgroundColor, opacity, position, transform), use Core Animation instead of draw(_:). CALayer properties update on the GPU without calling draw(_:), providing 60 FPS with no CPU load.

Batch update through CATransaction

To group multiple changes into a single rendering pass, use CATransaction. This allows combining multiple setNeedsDisplay() calls into one draw(_:) operation at the end of the transaction.

CATransaction.begin()
CATransaction.setDisableActions(true)

view1.setNeedsDisplay()
view2.setNeedsDisplay()
view3.setNeedsDisplay()

CATransaction.commit()

Do not overuse displayIfNeeded() — synchronous redrawing blocks the main thread and can cause frame drops. Use it only for operations where the drawing result is critical before the current run loop ends.