# Guideline 4.0 - Design: Dynamic Type and Large Text Not Supported

**Guideline:** 4.0 · **Store:** Apple App Store · **Risk:** low · **Difficulty:** medium · **Typical turnaround:** 4-8 hours

Canonical URL: https://appstorereject.com/rejections/apple/4/guideline-40-design-dynamic-type-and-large-text-not-supported

## Description

Apple rejected your app because it does not respect the user's Dynamic Type preferences. When users increase their preferred text size in Settings → Accessibility → Display & Text Size, your app's text does not scale accordingly. This results in text that remains too small for users who need larger text, or layouts that break, truncate, or overlap when large text sizes are enabled. Apple expects all apps to support Dynamic Type for body text, labels, and buttons.

## Common variations

- All text uses hardcoded point sizes and ignores Dynamic Type preferences
- Text scales with Dynamic Type but layouts break — text is truncated or overlaps
- Navigation bar and tab bar labels do not scale with text size settings
- Custom controls (buttons, badges, tags) use fixed sizes that clip large text
- App supports standard Dynamic Type sizes but breaks at accessibility sizes (AX1–AX5)

## Example rejection email

```
Your app does not sufficiently support text accessibility features.

Specifically, your app does not respond to the user's preferred text size setting (Dynamic Type). When the reviewer increased the text size to the largest accessibility size, text throughout the app remained at a fixed size and did not scale. Additionally, in some areas where text did partially scale, it was truncated or overlapped with other elements. Next Steps: Please update your app to support Dynamic Type and ensure layouts adapt to all text sizes.
```

## Resolution steps

## How to Fix Dynamic Type and Large Text Not Supported

1. **Replace hardcoded font sizes with text styles** — In SwiftUI, use semantic font modifiers instead of `.system(size:)`:

   ```swift
   // Before: .font(.system(size: 14))
   // After:
   .font(.body)       // 17pt default, scales with Dynamic Type
   .font(.headline)   // 17pt bold, scales
   .font(.caption)    // 12pt, scales
   ```

   In UIKit, use `UIFont.preferredFont(forTextStyle:)`.

2. **Use @ScaledMetric for custom sizes** — When you need a specific size that still scales:

   ```swift
   @ScaledMetric(relativeTo: .body) private var iconSize: CGFloat = 24

   Image(systemName: "star")
       .frame(width: iconSize, height: iconSize)
   ```

3. **Enable text wrapping, not truncation** — Ensure labels can expand vertically at large sizes:

   ```swift
   Text("Long label text")
       .lineLimit(nil)             // allow unlimited lines
       .fixedSize(horizontal: false, vertical: true) // grow vertically
   ```

   In UIKit, set `label.numberOfLines = 0` and `label.adjustsFontForContentSizeCategory = true`.

4. **Adapt layouts for large text** — At accessibility sizes, horizontal layouts may need to become vertical. Use `@Environment(\.dynamicTypeSize)` to switch:

   ```swift
   @Environment(\.dynamicTypeSize) var typeSize

   if typeSize.isAccessibilitySize {
       VStack { labelContent; valueContent }
   } else {
       HStack { labelContent; Spacer(); valueContent }
   }
   ```

5. **Ensure scroll views accommodate large text** — Wrap content in ScrollView so that screens with lots of text remain usable at the largest sizes rather than clipping at the bottom.

6. **Test at all 12 Dynamic Type sizes** — In the iOS Simulator, use the Environment Overrides panel (Debug → Environment Overrides) to test at every size from xSmall to AX5. Pay special attention to AX1–AX5 (accessibility sizes) where most breakage occurs.

7. **Use Accessibility Inspector** — Xcode's Accessibility Inspector can audit your app for Dynamic Type support issues and highlight elements that don't scale.

## Appeal guidance

Do not appeal this rejection. Dynamic Type support is an accessibility requirement that Apple takes seriously. The fix may take a few hours but is well worth it — it benefits users with low vision and is the right thing to do. If you've already added Dynamic Type support and the reviewer missed it, provide screenshots at the largest text size in your Resolution Center reply.

## Before / after examples

**Before:** // Hardcoded sizes — no Dynamic Type support
VStack(alignment: .leading, spacing: 8) {
    Text(item.title)
        .font(.system(size: 16, weight: .bold))
    Text(item.subtitle)
        .font(.system(size: 14))
        .lineLimit(1)
    HStack {
        Image(systemName: "star")
            .frame(width: 16, height: 16)
        Text(item.rating)
            .font(.system(size: 12))
    }
}
**After:** // Dynamic Type with adaptive layout
@ScaledMetric(relativeTo: .caption) private var starSize: CGFloat = 16

VStack(alignment: .leading, spacing: 8) {
    Text(item.title)
        .font(.headline)
    Text(item.subtitle)
        .font(.subheadline)
        .lineLimit(nil)
        .fixedSize(horizontal: false, vertical: true)
    HStack {
        Image(systemName: "star")
            .frame(width: starSize, height: starSize)
        Text(item.rating)
            .font(.caption)
    }
}
**Why it works:** Replace .system(size:) with semantic text styles (.headline, .subheadline, .caption) that scale automatically with Dynamic Type. Use @ScaledMetric for icon sizes so they grow proportionally. Remove lineLimit(1) to allow text to wrap at large sizes.

**Before:** // Fixed horizontal layout that breaks at large text
HStack {
    Text("Balance:")
        .font(.system(size: 14))
    Spacer()
    Text("$1,234.56")
        .font(.system(size: 14, weight: .bold))
}
**After:** // Adaptive layout that stacks vertically at accessibility sizes
@Environment(\.dynamicTypeSize) var typeSize

Group {
    if typeSize.isAccessibilitySize {
        VStack(alignment: .leading, spacing: 4) {
            Text("Balance:")
                .font(.subheadline)
            Text("$1,234.56")
                .font(.headline)
        }
    } else {
        HStack {
            Text("Balance:")
                .font(.subheadline)
            Spacer()
            Text("$1,234.56")
                .font(.headline)
        }
    }
}
**Why it works:** At accessibility text sizes, horizontal space is too limited for side-by-side labels. Use @Environment(\.dynamicTypeSize) to detect large sizes and switch to a vertical layout, preventing truncation and overlap.

## Common questions

**Can you appeal a 4.0 rejection?**

Do not appeal this rejection. Dynamic Type support is an accessibility requirement that Apple takes seriously. The fix may take a few hours but is well worth it — it benefits users with low vision and is the right thing to do. If you've already added Dynamic Type support and the reviewer missed it, provide screenshots at the largest text size in your Resolution Center reply.

**How long does this typically take to fix?**

Typical turnaround is 4-8 hours (difficulty: medium). After resubmission, most re-reviews complete within 24-48 hours.

---
*Machine-readable source: https://api.appstorereject.com/api/rejections/detail?slug=guideline-40-design-dynamic-type-and-large-text-not-supported*