Today Widget: what it is, types and creating a notification widget

What Is Today Widget

Today Widget (also known as the Notification Center widget) is an iOS interface element that displays condensed information from an app without launching it. The user sees the widget by swiping left on the Lock Screen or on the Home Screen. The widget can show dynamic data — exchange rates, latest news, task status, device state.

Historically, Today Widget appeared in iOS 8 as a Notification Center extension implemented through the Notification Center framework. With iOS 14, Apple introduced WidgetKit — a completely redesigned architecture that allows placing widgets directly on the Home Screen. Today Widget in the modern sense is a WidgetKit widget placed in the “Today” section (the widget section to the left of the first screen).

Why Do You Need a Today Widget

The main goal is to reduce the time to access information. Instead of opening the app, navigating menus and waiting for loading, the user immediately sees the needed data. According to Apple (2024), apps with widgets show 27% higher user engagement. Additional use cases: quick actions (mark a task as completed), monitoring (heart rate, activity), and status (battery charge, notifications).

WidgetKit vs NCWidgetProviding

A Today Widget developer has two approaches available: modern WidgetKit (iOS 14+) and the legacy NCWidgetProviding extension (iOS 8–13). The choice depends on the minimum supported iOS version. WidgetKit is recommended for new projects, NCWidgetProviding for supporting older devices.

When to Use WidgetKit

If your app supports iOS 14 and newer — use WidgetKit. It provides rich capabilities: multiple sizes, configuration through intents, redesign with iOS 17, and deep links. SwiftUI declarativeness makes widget code compact and readable. Timeline Provider automatically manages the update schedule with power consumption in mind.

When to Use NCWidgetProviding

Only if iOS 9–13 support is required. NCWidgetProviding is simpler to implement — it’s a regular UIViewController with a protocol. However, it is limited: a single size, UIKit-only, no configuration. Apple recommends switching to WidgetKit even for old projects using availability check: WidgetKit on iOS 14+, NCWidgetProviding as fallback.

Types of Today Widgets

In modern iOS, there are three types of widgets by functional purpose. Each type solves its own problem and requires a different approach to data and interface design. Classification helps to choose the right architecture for your app.

Informational Widgets

Display static or periodically updated information: weather, date, exchange rates, server status. Data is updated on a schedule via Timeline Provider. The user does not interact with the widget — only reads. Informational widgets are the simplest to implement, do not require touch event handling and work in the background without additional permissions.

Interactive Widgets

With iOS 17, WidgetKit supports buttons, toggles and sliders in widgets. The user can perform an action — mark a task, pause music, turn on a light — without opening the app. Interactive Widgets use App Intents to pass actions to the main app. Limitation: only on the Home Screen, not in the “Today” section until iOS 18.

Configurable Widgets

The user customizes the displayed data through the system interface — selects a city for weather, an account for finances, a category for news. Implemented through Intents Extension and configuration in WidgetBundle. Configurable widgets increase personalization and relevance of information for each user.

Creating a WidgetKit Widget

Let’s look at the process of creating a Today Widget in SwiftUI using WidgetKit. The widget will display the current exchange rate with automatic updates. WidgetKit requires three components: a widget structure, a Provider with configuration, and a View for display.

import WidgetKit
import SwiftUI

@main
struct CurrencyWidget: Widget {
    let kind: String = "CurrencyWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            CurrencyWidgetEntryView(entry: entry)
        }
        .configurationDisplayName("Currency Rate")
        .description("Current USD/RUB exchange rate")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

The Provider is responsible for preparing data for display. The getTimeline method creates an update schedule: the next update in 15 minutes. TimelineProvider ensures that the widget shows up-to-date data without constantly polling the server.

struct Provider: TimelineProvider {
    func getSnapshot(in context: Context,
                      completion: @escaping (CurrencyEntry) -> Void) {
        let entry = CurrencyEntry(date: Date(), rate: 92.5)
        completion(entry)
    }

    func getTimeline(in context: Context,
                     completion: @escaping (Timeline<CurrencyEntry>) -> Void) {
        let rate = CurrencyService().fetchRate()
        let entry = CurrencyEntry(date: Date(), rate: rate)
        let nextUpdate = Calendar.current.date(
            byAdding: .minute, value: 15, to: Date()
        ) ?? Date()
        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
        completion(timeline)
    }
}

Timeline Provider and Data Updates

Timeline Provider is the central WidgetKit mechanism for managing Today Widget data. Instead of periodic updates by timer (as in the old NCWidgetProviding), WidgetKit uses the concept of a timeline — a sequence of entries with timestamps. The system displays the current entry until it expires, then switches to the next one or requests a new one.

Update Policies

Timeline supports three policies: .after(date) — next update at the specified date; .never — the widget does not update until an explicit call to WidgetCenter.reloadAllTimelines; .atEnd — update after displaying the last entry. For a Today Widget with exchange rates, the .after policy with a 15–30 minute interval is optimal. Energy efficiency is a key advantage of WidgetKit: the system groups updates of all widgets in one window.

WidgetCenter: Programmatic Update

If the data changed before the timeline expires (for example, the user updated the rate in the app), call WidgetCenter.shared.reloadTimelines(ofKind: “CurrencyWidget”). This will request a new timeline from the Provider and update the display. WidgetCenter also allows reloading all app widgets with a single command — convenient after data synchronization.

Widget Design Guidelines

Apple imposes strict requirements on Today Widget design: content must be readable at a glance, without unnecessary elements and with a clear hierarchy. Violating HIG (Human Interface Guidelines) recommendations is a reason for rejection when publishing on the App Store. Three principles: glanceability, consistency and hierarchy.

Glanceability — Readable at a Glance

The user spends less than a second on a widget. Do not add more than 3–4 data elements. Font — minimum 11pt for labels, 17pt for values. Use bold (Semibold) for key numbers. Avoid scrolling — Today Widget does not scroll.

Adapting to Sizes

WidgetKit supports three sizes: Small (170×170pt), Medium (364×170pt), Large (364×382pt). For Today Widget in the “Today” section, Medium is the most common choice. Adaptive design through EnvironmentValues: change information density depending on size. Small — one number, Medium — number + chart, Large — table.

Dark Mode and Dynamic Type Support

The widget should display correctly in light and dark themes without additional developer actions — WidgetKit automatically picks up system colors. Dynamic Type for widgets is limited: the font size is fixed, but should be readable. UIColor.label and UIColor.systemBackground are the base colors for text and background in both themes.