Bold Text in Mobile Apps: What It Is and How to Configure Bold Text

What Is Bold Text in Accessibility?

Bold Text is a system setting in operating systems that forces the use of a bold font weight for all text interface elements instead of the standard (regular or normal) weight. Unlike simply increasing the font size, Bold Text does not change the scale — it increases the thickness of letter strokes, making them richer and more contrast against the background.

This feature belongs to the category of display accommodations — screen settings that help people with visual impairments perceive information more comfortably. Bold Text is particularly effective for low visual acuity (amblyopia), age-related farsightedness (presbyopia), and certain forms of dyslexia where letters appear double or blurry at standard thickness.

Bold text increases readability — the speed and accuracy of recognizing individual characters. Studies from Usability.gov show that bold typeface improves reading accuracy by 12–18% in users with visual impairments compared to regular typeface at the same point size. However, Bold Text does not replace text enlargement — both features can be combined.

Difference Between Bold Text and Font Enlargement

The key difference between Bold Text and Dynamic Type (iOS) or Font Size (Android) is the mechanism of effect. Font enlargement changes the size of letters, while Bold Text only affects thickness. When enlarging the font, screen capacity suffers (less content fits on one screen), whereas Bold Text preserves the number of visible elements. For users with early-stage presbyopia, Bold Text is often sufficient without text enlargement.

Who Needs Bold Text

The primary audience for Bold Text includes people with amblyopia (reduced visual acuity not correctable with glasses), presbyopia (age-related farsightedness after age 40–45), and certain forms of dyslexia. The feature is also useful when reading in bright sunlight — bold text maintains contrast against glare. Assistive technologies such as VoiceOver and TalkBack work independently of Bold Text — the setting only affects visual display.

Bold Text in iOS: Settings and How It Works

In iOS, Bold Text is one of the oldest accessibility features, introduced in iOS 7 (2013). The setting is located in Settings > Display & Brightness > Bold Text and requires an iPhone restart: the system rebuilds all fonts in system applications (Settings, Mail, Messages, Calendar, Notes) and third-party apps that use the system font San Francisco.

Technically, iOS replaces the system font file San Francisco with its Bold variant (SF Pro Bold / SF Pro Rounded Bold) at the CoreText framework level. After enabling Bold Text, all on-screen text — from navigation headers to button labels — displays with font-weight 700 instead of 400. A developer cannot override this behavior for system elements but can manage fonts in their own UI through Dynamic Type.

For developers, when Bold Text is enabled, all UIFont instances with textStyle (.body, .headline, .caption, and others) automatically receive bold weight. UIFontWeight exists in two variants: regular (0.0) and bold (1.0). With Bold Text active, the system increases fontWeight by 0.3–0.5 for each style. The status can be checked via UIAccessibility.isBoldTextEnabled.

Checking Bold Text in an iOS App

A developer can check whether Bold Text is enabled on the device and adapt the interface accordingly. For example, if table headers already use bold, enabling the feature may require reducing the font weight to avoid visual noise. The check uses the UIAccessibility framework.

import UIKit

class BoldTextManager {

    // Checking Bold Text status
    static var isBoldTextEnabled: Bool {
        return UIAccessibility.isBoldTextEnabled
    }

    // Adapting font for Bold Text
    static func adjustedFont(
        textStyle: UIFont.TextStyle,
        weight: UIFont.Weight
    ) -> UIFont {
        let baseFont = UIFont.preferredFont(
            forTextStyle: textStyle
        )
        guard isBoldTextEnabled else {
            return baseFont
        }
        // Reducing boldness to avoid double-bold
        let adjustedWeight: UIFont.Weight
        switch weight {
        case .bold, .heavy:
            adjustedWeight = .semibold
        case .semibold:
            adjustedWeight = .medium
        default:
            adjustedWeight = weight
        }
        return UIFont.systemFont(
            ofSize: baseFont.pointSize,
            weight: adjustedWeight
        )
    }

    // Cached font with Bold Text support
    static func labelFont() -> UIFont {
        return adjustedFont(
            textStyle: .body,
            weight: .regular
        )
    }
}

// Subscribing to Bold Text changes (Notification)
NotificationCenter.default.addObserver(
    self,
    selector: #selector(boldTextStatusChanged),
    name: UIAccessibility.boldTextStatusDidChangeNotification,
    object: nil
)

@objc func boldTextStatusChanged() {
    // Update UI when Bold Text changes
    updateFonts()
}

The BoldTextManager class checks isBoldTextEnabled, adapts the font weight (reduces heavy/bold to semibold/medium when the feature is active), and subscribes to the boldTextStatusDidChangeNotification. This prevents the double-bold effect, where a developer already uses bold for headings and the system thickens them even further.

Impact on UITableView and UICollectionView

Bold Text affects the layout of UITableView and UICollectionView cells, as increasing font thickness can change row height. When using self-sizing cells (estimatedRowHeight + UITableView.automaticDimension), iOS automatically recalculates height when the font changes. For fixed cell heights, the developer needs to call reloadData() after receiving the boldTextStatusDidChangeNotification, otherwise text may be truncated.

Improve Readability in Android: The Bold Text Equivalent

On Android, the Bold Text feature is called “Improve Readability” in the settings interface and is located in the Accessibility section. On some Android versions, especially on Samsung One UI devices, the feature is called “High Contrast Text.” The setting applies to all system elements and most third-party applications.

The technical implementation on Android differs from iOS: instead of replacing the system font, Android overrides Typeface at the system level through Resources.Theme. When the setting is activated, the system changes the android:textStyle attribute for all text elements, setting bold or italic+bold. A developer can check the status via Settings.Global.getFloat() or AccessibilityManager.

Checking Bold Text in an Android App

In Android, there is no direct equivalent to UIAccessibility.isBoldTextEnabled API. The check is performed through ContentResolver and Settings.System. The setting is stored in global preferences as font_weight_adjustment. For Jetpack Compose, it is accessible via LocalDensity and fontScale.

import android.content.Context
import android.provider.Settings
import android.util.TypedValue
import androidx.compose.ui.text.font.FontWeight

class AndroidBoldTextHelper {

    // Checking improved readability through system settings
    fun isBoldTextEnabled(context: Context): Boolean {
        return try {
            Settings.System.getInt(
                context.contentResolver,
                "font_weight_adjustment"
            ) == 1
        } catch (e: Settings.SettingNotFoundException) {
            false
        }
    }

    // Jetpack Compose — FontWeight adaptation
    fun adjustFontWeight(
        context: Context,
        original: FontWeight
    ): FontWeight {
        if (!isBoldTextEnabled(context)) return original

        return when (original) {
            FontWeight.Bold, FontWeight.ExtraBold -> FontWeight.SemiBold
            FontWeight.SemiBold -> FontWeight.Medium
            else -> original
        }
    }

    // XML View — applying via TypedValue
    fun applyBoldStyleFix(context: Context, textView: android.widget.TextView) {
        if (isBoldTextEnabled(context)) {
            val paint = textView.paint
            val fakeBold = paint.isFakeBoldText
            // Reducing fakeBold if already enabled by the system
            if (fakeBold) {
                paint.isFakeBoldText = false
                textView.invalidate()
            }
        }
    }
}

The AndroidBoldTextHelper class reads the system font_weight_adjustment setting, adapts FontWeight in Jetpack Compose, and removes duplicate fakeBold in XML View. Unlike iOS, Android does not provide a notification channel for Bold Text changes — the developer checks the setting at Activity startup or through ContentObserver.

ContentObserver for Tracking Changes

To track Bold Text changes at runtime, an Android developer can use ContentObserver. When the font_weight_adjustment setting changes, the system notifies the ContentResolver, and the app can update its UI. This is important for AccessibilityService and custom launchers that must respond instantly to user setting changes.

CSS font-weight: Font Thickness Types

In web development, font thickness is controlled by the CSS property font-weight with values ranging from 100 (Thin) to 900 (Black). Standard values include normal = 400 and bold = 700. Bold Text in the operating system does not directly affect CSS font-weight — web browsers do not receive a system signal about enabled Bold Text at the CSS level. However, a developer can use a CSS media feature if the platform supports it.

For iOS, Safari supports the -webkit-text-size-adjust media function but does not have a direct media query for Bold Text. On Android, Chrome also does not provide a media query for the system bold text setting. Web developers are advised to use prefers-contrast and prefers-reduced-motion for adaptation, and for bold text — check the setting via User-Agent or fallback styles.

Using Variable Fonts

Variable Fonts (OpenType Font Variations) allow smooth adjustment of font thickness through CSS font-weight in the range of 1–999 in increments of 1 unit. Unlike standard fonts where only discrete values (400, 700) are available, variable fonts make it possible to choose the optimal weight for each user. A wider range can be used for accessibility settings.

/* Variable font with smooth thickness adjustment */
@font-face {
    font-family: "Inter Variable";
    src: url("/fonts/Inter-Variable.woff2")
        format("woff2-variations");
    font-weight: 100 900;
    font-stretch: 50% 200%;
}

/* Adaptation to system Bold Text via class */
.bold-text-enabled {
    --font-weight-body: 500;
    --font-weight-heading: 700;
}

.bold-text-enabled .text-body {
    font-weight: var(--font-weight-body);
}

.bold-text-enabled .text-heading {
    font-weight: var(--font-weight-heading);
}

/* prefers-contrast: more — fallback approach */
@media (prefers-contrast: more) {
    .content {
        --font-weight-increase: 100;
    }
    .content .text {
        font-weight: calc(
            var(--font-weight-base) +
            var(--font-weight-increase)
        );
    }
}

The CSS example shows how to load the Inter Variable variable font, use CSS custom properties for weight control, and adapt via prefers-contrast: more. Variable fonts allow increasing font-weight by 50–100 units when the system Bold Text is enabled without losing rendering quality. To detect Bold Text status on the client, JavaScript can check the User-Agent and add a class to the html element.

JavaScript Detection of Bold Text on a Web Page

Since CSS does not provide a direct media query for Bold Text, web developers use JavaScript: they create an invisible element with a known font, measure its width, change the font-weight, and compare the difference. If the difference is larger than expected, the system Bold Text is likely active. This method is used in accessibility libraries for automatic style adjustment.

How Bold Text Affects App Accessibility

Bold Text addresses specific problems for users with visual impairments: it improves character distinguishability in amblyopia, reduces visual fatigue during prolonged reading, and compensates for low display contrast in bright sunlight. According to the WebAIM Million (2025), 12.3% of all pages have text with insufficient contrast — Bold Text can partially compensate for this defect on the user side.

For developers, Bold Text support is part of WCAG 2.2 requirements: criterion 1.4.1 (Use of Color) and 1.4.3 (Contrast Minimum). The app must display correctly with the system Bold Text setting enabled without content loss, element overlap, or text truncation. Testing with Bold Text enabled is mandatory when preparing for App Store and Google Play publication.

Testing Recommendations

When testing an app with Bold Text, check: whether all text elements display fully (without truncation), whether boldness is duplicated (double-bold), whether cell heights in tables are recalculated correctly, and whether elements shift relative to each other. Use Accessibility Inspector (Xcode) or Accessibility Scanner (Android) to automatically detect Bold Text issues.

• Xcode Accessibility Inspector — font audit with Bold Text simulation mode
• Android Accessibility Scanner — contrast ratio and font-weight duplication check
• UI Testing — screenshot tests with Bold Text enabled and disabled
• Dynamic Type testing — combination of Bold Text + enlarged font

The Future of Bold Text on Mobile Platforms

Modern iOS and Android are evolving Bold Text toward finer control: iOS 18 (2024) added per-app font settings, including bold weight, and Android 16 (2025) expanded the font_weight_adjustment API for developers. Future versions are expected to provide a CSS media query for Bold Text, eliminating the need for JavaScript detection.