pt — what it is, Points and scaling in iOS

What is pt in iOS?

pt (point) — a logical unit of measurement in iOS that allows developers to describe the interface in abstract coordinates, independent of the physical display resolution. Apple introduced the concept of points with the release of the iPhone 4 and Retina display in 2010. Before Retina, developers used pixels directly — one UI pixel equaled one physical pixel.

The iOS coordinate system is built on points: point (0,0) is in the upper-left corner of the screen, the X axis goes right, the Y axis goes down. The screen size in points remains constant for each device class: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (portrait), 1024×768 pt (landscape). Physical resolution can be 1179×2556 px (iPhone 15 Pro) — but the developer works with points.

According to the Apple Human Interface Guidelines, points are the fundamental abstraction of UIKit. All frameworks — UIKit, SwiftUI, Core Graphics, SpriteKit — operate in points. Conversion to pixels occurs automatically at the rendering stage via UIScreen.nativeScale.

Scale factors: @1x, @2x, @3x

The scale factor determines how many physical pixels correspond to one logical point. Apple uses three levels: @1x — 1 pt = 1 px (iPad mini without Retina, older models), @2x — 1 pt = 2 px (most iPhones before 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X and newer, including iPhone 15 Pro).

The scale factor is accessible via UIScreen.main.scale (for UIKit) and @Environment(\.displayScale) (for SwiftUI). It is used when loading assets: the system automatically selects the image with the @2x or @3x suffix from Assets.xcassets. Developers should not load @1x images on Retina devices — this reduces performance and quality.

CGPoint and coordinates in points

The CGPoint structure is the basic type for representing coordinates in iOS and macOS. It contains two fields: x (CGFloat) and y (CGFloat), values are specified in points. CGPoint is used in all Apple frameworks: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — working with coordinates in points
import UIKit

// Creating a point
let point = CGPoint(x: 100.0, y: 200.0)
print("Coordinates: \(point.x), \(point.y)")

// Mathematical operations
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Distance between points
func distance(from a: CGPoint, to b: CGPoint) -> CGFloat {
    let dx = b.x - a.x
    let dy = b.y - a.y
    return sqrt(dx * dx + dy * dy)
}

// Converting points to pixels
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

The toPixels method in the example demonstrates converting points to physical pixels via UIScreen.main.scale. In UIKit, this conversion happens automatically during rendering, but in Core Graphics and when working with Metal, the developer may need explicit pixel conversion. All animation calculations, collision detection, and layout are performed in points.

UIFont.pointSize and typography

The UIFont.pointSize property returns the font size in points — this is the standard typography unit in iOS, inherited from print (1 pt = 1/72 inch). Apple has used pt for fonts since the early versions of Mac OS. In iOS, font size is specified in points via UIFont.systemFont(ofSize:) or via SwiftUI Font.system(size:).

// Working with UIFont.pointSize in Swift
import UIKit

// Creating a font with size in pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Reading pointSize
print("Title size: \(titleFont.pointSize) pt")

// Dynamic Type — automatic scaling
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Scaled: \(scaledFont.pointSize) pt")

// Comparing font sizes
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics is a dynamic font scaling mechanism added in iOS 11. It automatically adjusts pointSize based on the user accessibility settings (Settings > Display & Brightness > Text Size). Without using UIFontMetrics, fonts do not scale, which violates WCAG accessibility requirements.

pt vs px: what is the difference

The difference between pt and px is critical for understanding iOS development. pt is a logical unit, px is a physical unit. One point can correspond to 1, 2, or 3 pixels depending on the scale factor. The developer operates in points, the system converts them to pixels at the rasterization stage.

Key takeaway: the interface size in points is the same across all devices of the same class. A 375 pt wide screen — this applies to both iPhone SE and iPhone 14 (base model). The only difference is how many physical pixels fit into those 375 pt. This ensures a uniform UI without manual adaptation for each device.

pt in SwiftUI

In SwiftUI, the developer does not explicitly operate in points — all sizes are specified via Dp (device-independent points, equivalent to pt). SwiftUI automatically applies the scale factor during rendering but provides access to it through the environment value displayScale.

// SwiftUI — working with points and scale factor
import SwiftUI

struct ContentView: View {
    @Environment(\.displayScale) private var displayScale

    var body: some View {
        VStack(spacing: 16) {
            Text("Title")
                .font(.system(size: 28, weight: .bold))

            Text("Example body text")
                .font(.body)

            HStack {
                Text("Scale factor:")
                    .font(.caption)
                Text("\(displayScale, specifier: "%.1f")")
                    .font(.caption.weight(.bold))
            }
        }
        .padding(20)
        .frame(width: 300)
    }
}

SwiftUI abstracts pt at the framework level. .font(.body) automatically uses Dynamic Type — the font size adjusts to the user settings. SwiftUI does not allow specifying font size in pixels — only through Font and the typography system. This guarantees interface accessibility without additional developer effort.