eventkit-calendar

Create, read, and manage calendar events and reminders using EventKit and EventKitUI. Use when adding events to the user's calendar, creating reminders,…

installs

stars

karma

SkillRank score ↗

8.4/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-06-24

eventkit-calendar provides comprehensive coverage of ios calendar and reminder management through eventkit and eventkitui, including crud operations, recurrence rules, alarms, and authorization workflows.

structure

9.0

trigger phrases

6.0

procedure

9.0

edge cases

8.0

documentation

9.0

strengths

view original SKILL.md from skills.shclick to expand

EventKit — Calendar & Reminders

Create, read, and manage calendar events and reminders. Covers authorization,
event and reminder CRUD, recurrence rules, alarms, and EventKitUI editors.
Targets Swift 6.2 / iOS 26+.

Contents

Setup

Authorization

Creating Events

Fetching Events

Reminders

Recurrence Rules

Alarms

EventKitUI Controllers

Observing Changes

Common Mistakes

Review Checklist

References

Setup

Info.plist Keys

Add the required usage description strings based on what access level you need:

Key
Access Level

NSCalendarsFullAccessUsageDescription
Read + write events

NSCalendarsWriteOnlyAccessUsageDescription
Write-only events (iOS 17+)

NSRemindersFullAccessUsageDescription
Read + write reminders

For apps also targeting iOS 16 or earlier, also include the legacy NSCalendarsUsageDescription / NSRemindersUsageDescription keys.

Event Store

Create a single EKEventStore instance and reuse it. Do not mix objects from
different event stores.

import EventKit

let eventStore = EKEventStore()

Authorization

iOS 17+ introduced granular access levels. Use the modern async methods.

Full Access to Events

func requestCalendarAccess() async throws -> Bool {
    let granted = try await eventStore.requestFullAccessToEvents()
    return granted
}

Write-Only Access to Events

Use when your app only creates events (e.g., saving a booking) and does not
need to read existing events.

func requestWriteAccess() async throws -> Bool {
    let granted = try await eventStore.requestWriteOnlyAccessToEvents()
    return granted
}

Full Access to Reminders

func requestRemindersAccess() async throws -> Bool {
    let granted = try await eventStore.requestFullAccessToReminders()
    return granted
}

Checking Authorization Status

let status = EKEventStore.authorizationStatus(for: .event)

switch status {
case .notDetermined:
    // Request access
    break
case .fullAccess:
    // Read and write allowed
    break
case .writeOnly:
    // Write-only access granted (iOS 17+)
    break
case .restricted:
    // Parental controls or MDM restriction
    break
case .denied:
    // User denied -- direct to Settings
    break
@unknown default:
    break
}

Creating Events

func createEvent(
    title: String,
    startDate: Date,
    endDate: Date,
    calendar: EKCalendar? = nil
) throws {
    let event = EKEvent(eventStore: eventStore)
    event.title = title
    event.startDate = startDate
    event.endDate = endDate
    event.calendar = calendar ?? eventStore.defaultCalendarForNewEvents

    try eventStore.save(event, span: .thisEvent)
}

Setting a Specific Calendar

// List writable calendars
let calendars = eventStore.calendars(for: .event)
    .filter { $0.allowsContentModifications }

// Use the first writable calendar, or the default
let targetCalendar = calendars.first ?? eventStore.defaultCalendarForNewEvents
event.calendar = targetCalendar

Adding Structured Location

import CoreLocation

let location = EKStructuredLocation(title: "Apple Park")
location.geoLocation = CLLocation(latitude: 37.3349, longitude: -122.0090)
event.structuredLocation = location

Fetching Events

Use a date-range predicate to query events. The events(matching:) method
returns occurrences of recurring events expanded within the range.

func fetchEvents(from start: Date, to end: Date) -> [EKEvent] {
    let predicate = eventStore.predicateForEvents(
        withStart: start,
        end: end,
        calendars: nil  // nil = all calendars
    )
    return eventStore.events(matching: predicate)
        .sorted { $0.startDate < $1.startDate }
}

Fetching a Single Event by Identifier

if let event = eventStore.event(withIdentifier: savedEventID) {
    print(event.title ?? "No title")
}

Reminders

Creating a Reminder

func createReminder(title: String, dueDate: Date) throws {
    let reminder = EKReminder(eventStore: eventStore)
    reminder.title = title
    reminder.calendar = eventStore.defaultCalendarForNewReminders()

    let dueDateComponents = Calendar.current.dateComponents(
        [.year, .month, .day, .hour, .minute],
        from: dueDate
    )
    reminder.dueDateComponents = dueDateComponents

    try eventStore.save(reminder, commit: true)
}

Fetching Reminders

Reminder fetches are asynchronous and return through a completion handler.

func fetchIncompleteReminders() async -> [EKReminder] {
    let predicate = eventStore.predicateForIncompleteReminders(
        withDueDateStarting: nil,
        ending: nil,
        calendars: nil
    )

    return await withCheckedContinuation { continuation in
        eventStore.fetchReminders(matching: predicate) { reminders in
            continuation.resume(returning: reminders ?? [])
        }
    }
}

Completing a Reminder

func completeReminder(_ reminder: EKReminder) throws {
    reminder.isCompleted = true
    try eventStore.save(reminder, commit: true)
}

Recurrence Rules

Use EKRecurrenceRule to create repeating events or reminders.

Simple Recurrence

// Every week, indefinitely
let weeklyRule = EKRecurrenceRule(
    recurrenceWith: .weekly,
    interval: 1,
    end: nil
)
event.addRecurrenceRule(weeklyRule)

// Every 2 weeks, ending after 10 occurrences
let biweeklyRule = EKRecurrenceRule(
    recurrenceWith: .weekly,
    interval: 2,
    end: EKRecurrenceEnd(occurrenceCount: 10)
)

// Monthly, ending on a specific date
let monthlyRule = EKRecurrenceRule(
    recurrenceWith: .monthly,
    interval: 1,
    end: EKRecurrenceEnd(end: endDate)
)

Complex Recurrence

// Every Monday and Wednesday
let days = [
    EKRecurrenceDayOfWeek(.monday),
    EKRecurrenceDayOfWeek(.wednesday)
]

let complexRule = EKRecurrenceRule(
    recurrenceWith: .weekly,
    interval: 1,
    daysOfTheWeek: days,
    daysOfTheMonth: nil,
    monthsOfTheYear: nil,
    weeksOfTheYear: nil,
    daysOfTheYear: nil,
    setPositions: nil,
    end: nil
)
event.addRecurrenceRule(complexRule)

Editing Recurring Events

When saving changes to a recurring event, specify the span:

// Change only this occurrence
try eventStore.save(event, span: .thisEvent)

// Change this and all future occurrences
try eventStore.save(event, span: .futureEvents)

Alarms

Attach alarms to events or reminders to trigger notifications.

// 15 minutes before
let alarm = EKAlarm(relativeOffset: -15 * 60)
event.addAlarm(alarm)

// At an absolute date
let absoluteAlarm = EKAlarm(absoluteDate: alertDate)
event.addAlarm(absoluteAlarm)

EventKitUI Controllers

EKEventEditViewController — Create/Edit Events

Present the system event editor for creating or editing events.

import EventKitUI

class EventEditorCoordinator: NSObject, EKEventEditViewDelegate {
    let eventStore = EKEventStore()

    func presentEditor(from viewController: UIViewController) {
        let editor = EKEventEditViewController()
        editor.eventStore = eventStore
        editor.editViewDelegate = self
        viewController.present(editor, animated: true)
    }

    func eventEditViewController(
        _ controller: EKEventEditViewController,
        didCompleteWith action: EKEventEditViewAction
    ) {
        switch action {
        case .saved:
            // Event saved
            break
        case .canceled:
            break
        case .deleted:
            break
        @unknown default:
            break
        }
        controller.dismiss(animated: true)
    }
}

EKEventViewController — View an Event

import EventKitUI

let viewer = EKEventViewController()
viewer.event = existingEvent
viewer.allowsEditing = true
navigationController?.pushViewController(viewer, animated: true)

EKCalendarChooser — Select Calendars

let chooser = EKCalendarChooser(
    selectionStyle: .multiple,
    displayStyle: .allCalendars,
    entityType: .event,
    eventStore: eventStore
)
chooser.showsDoneButton = true
chooser.showsCancelButton = true
chooser.delegate = self
present(UINavigationController(rootViewController: chooser), animated: true)

Observing Changes

Register for EKEventStoreChanged notifications to keep your UI in sync when
events are modified outside your app (e.g., by the Calendar app or a sync).

NotificationCenter.default.addObserver(
    forName: .EKEventStoreChanged,
    object: eventStore,
    queue: .main
) { [weak self] _ in
    self?.refreshEvents()
}

Always re-fetch events after receiving this notification. Previously fetched
EKEvent objects may be stale.

Common Mistakes

DON'T: Use the deprecated requestAccess(to:) method

// WRONG: Deprecated in iOS 17
eventStore.requestAccess(to: .event) { granted, error in }

// CORRECT: Use the granular async methods
let granted = try await eventStore.requestFullAccessToEvents()

DON'T: Save events to a read-only calendar

// WRONG: No check -- will throw if calendar is read-only
event.calendar = someCalendar
try eventStore.save(event, span: .thisEvent)

// CORRECT: Verify the calendar allows modifications
guard someCalendar.allowsContentModifications else {
    event.calendar = eventStore.defaultCalendarForNewEvents
    return
}
event.calendar = someCalendar
try eventStore.save(event, span: .thisEvent)

DON'T: Ignore timezone when creating events

// WRONG: Event appears at wrong time for traveling users
event.startDate = Date()
event.endDate = Date().addingTimeInterval(3600)

// CORRECT: Set the timezone explicitly for location-specific events
event.timeZone = TimeZone(identifier: "America/New_York")
event.startDate = startDate
event.endDate = endDate

DON'T: Forget to commit batched saves

// WRONG: Changes never persisted
try eventStore.save(event1, span: .thisEvent, commit: false)
try eventStore.save(event2, span: .thisEvent, commit: false)
// Missing commit!

// CORRECT: Commit after batching
try eventStore.save(event1, span: .thisEvent, commit: false)
try eventStore.save(event2, span: .thisEvent, commit: false)
try eventStore.commit()

DON'T: Mix EKObjects from different event stores

// WRONG: Event fetched from storeA, saved to storeB
let event = storeA.event(withIdentifier: id)!
try storeB.save(event, span: .thisEvent) // Undefined behavior

// CORRECT: Use the same store throughout
let event = eventStore.event(withIdentifier: id)!
try eventStore.save(event, span: .thisEvent)

Review Checklist

 Correct Info.plist usage description keys added for calendars and/or reminders

 Authorization requested with iOS 17+ granular methods (requestFullAccessToEvents, requestWriteOnlyAccessToEvents, requestFullAccessToReminders)

 Authorization status checked before fetching or saving

 Single EKEventStore instance reused across the app

 Events saved to a writable calendar (allowsContentModifications checked)

 Recurring event saves specify correct EKSpan (.thisEvent vs .futureEvents)

 Batched saves followed by explicit commit()

 EKEventStoreChanged notification observed to refresh stale data

 Timezone set explicitly for location-specific events

 EKObjects not shared across different event store instances

 EventKitUI delegates dismiss controllers in completion callbacks

References

Extended patterns (SwiftUI wrappers, predicate queries, batch operations): references/eventkit-patterns.md

EventKit framework

EKEventStore

EKEvent

EKReminder

EKRecurrenceRule

EKCalendar

EventKit UI

EKEventEditViewController

EKCalendarChooser

Accessing the event store

Creating a recurring event

1d:["$

don't have the plugin yet? install it then click "run inline in claude" again.

restructured original reference material into implexa six-component format, made authorization decision logic explicit, added edge cases for read-only calendars/auth expiry/network timeouts, documented all inputs including plist keys and timezone handling, and clarified outcomes with specific calendar app behavior signals.

intent

use this skill to build calendar and reminder functionality into iOS apps. covers the full eventkit api: requesting granular calendar/reminder permissions, creating and fetching events, setting up recurring events with complex rules, attaching alarms, and presenting native apple ui editors. targets swift 6.2 / ios 17+. use when adding events to the user's calendar, creating reminders, editing recurring patterns, or presenting calendar pickers.

inputs

EKEventStore: single persistent instance, reused across the app. do not create multiple stores. do not mix objects from different stores.
Info.plist keys: add one or more of these based on your access needs:
- NSCalendarsFullAccessUsageDescription: read + write events
- NSCalendarsWriteOnlyAccessUsageDescription: write-only events (ios 17+)
- NSRemindersFullAccessUsageDescription: read + write reminders
- NSCalendarsUsageDescription / NSRemindersUsageDescription: legacy fallback for ios 16 and earlier
Date ranges: start and end dates for event queries (unix timestamps or Swift Date objects)
Calendar identifier: optional; if not specified, uses default calendar for new events or reminders
Recurrence parameters: frequency (daily, weekly, monthly, yearly), interval, occurrence count or end date, days of week/month
Location data: optional title and CLLocation (latitude, longitude) for structured event locations
Timezone identifier: string like "America/New_York"; omit only if event is all-day or user's local tz is correct

procedure

1. initialize and store the event store

create a single EKEventStore() instance at app launch or in your root view controller
store it as a property or singleton
reuse this instance for all calendar and reminder operations
input: none
output: initialized EKEventStore object

2. request authorization

call the appropriate async method based on your access level:
- let granted = try await eventStore.requestFullAccessToEvents() for read + write
- let granted = try await eventStore.requestWriteOnlyAccessToEvents() for write-only (ios 17+ only)
- let granted = try await eventStore.requestFullAccessToReminders() for reminders
wrap in do-catch to handle auth errors (e.g., user denied, system error)
input: event store instance
output: boolean indicating whether access was granted; if false, skip step 3+

3. check authorization status (optional, for ui state)

call EKEventStore.authorizationStatus(for: .event) or EKEventStore.authorizationStatus(for: .reminder)
inspect the status enum (notDetermined, fullAccess, writeOnly, restricted, denied)
input: none
output: authorization status enum value

4. create an event

instantiate EKEvent(eventStore: eventStore)
set title, startDate, endDate (required)
set calendar: check that calendar.allowsContentModifications is true; fallback to eventStore.defaultCalendarForNewEvents
optionally set structuredLocation with title and geoLocation (CLLocation)
optionally set timeZone: event.timeZone = TimeZone(identifier: "America/New_York")
call try eventStore.save(event, span: .thisEvent) to persist
input: title (string), startDate (date), endDate (date), optional calendar (EKCalendar), optional location (title + CLLocation), optional timezone (string identifier)
output: saved EKEvent object; throws if calendar is read-only or save fails

5. fetch events

build a predicate: let predicate = eventStore.predicateForEvents(withStart: startDate, end: endDate, calendars: nil)
call eventStore.events(matching: predicate) to get all occurrences in the range (recurring events are expanded)
optionally sort by startDate
input: start date, end date, optional calendar filter array
output: array of EKEvent objects, sorted or unsorted

6. fetch a single event by identifier

call eventStore.event(withIdentifier: eventID)
input: event identifier (string)
output: EKEvent object or nil if not found

7. create a reminder

instantiate EKReminder(eventStore: eventStore)
set title (required)
set calendar: reminder.calendar = eventStore.defaultCalendarForNewReminders()
convert due date to DateComponents: Calendar.current.dateComponents([.year, .month, .day, .hour, .minute], from: dueDate)
assign to reminder.dueDateComponents
call try eventStore.save(reminder, commit: true) to persist
input: title (string), due date (date)
output: saved EKReminder object; throws if save fails

8. fetch incomplete reminders

build a predicate: let predicate = eventStore.predicateForIncompleteReminders(withDueDateStarting: nil, ending: nil, calendars: nil)
call eventStore.fetchReminders(matching:) with a completion handler or wrap in withCheckedContinuation for async/await
input: optional start and end dates, optional calendar filter
output: array of EKReminder objects; empty array if none match

9. mark reminder as complete

load the reminder (step 8)
set reminder.isCompleted = true
call try eventStore.save(reminder, commit: true)
input: existing EKReminder object
output: updated reminder; throws if save fails

10. add recurrence rule (simple)

instantiate EKRecurrenceRule(recurrenceWith: .weekly, interval: 1, end: nil) for weekly indefinitely
or use EKRecurrenceEnd(occurrenceCount: 10) to end after N occurrences
or use EKRecurrenceEnd(end: endDate) to end on a specific date
call event.addRecurrenceRule(rule) or reminder.addRecurrenceRule(rule)
save the event/reminder
input: frequency (.daily, .weekly, .monthly, .yearly), interval (int), end condition (nil or EKRecurrenceEnd)
output: event/reminder with recurrence rule attached

11. add recurrence rule (complex)

create an array of EKRecurrenceDayOfWeek objects: [EKRecurrenceDayOfWeek(.monday), EKRecurrenceDayOfWeek(.wednesday)]
instantiate EKRecurrenceRule(recurrenceWith: .weekly, interval: 1, daysOfTheWeek: days, ...other params: nil, end: nil)
call event.addRecurrenceRule(rule)
save the event
input: frequency, interval, day/month/year constraints (arrays or nil), end condition
output: event with complex recurrence rule

12. edit a recurring event

fetch the event
modify properties (title, date, etc.)
decide on span: .thisEvent (this occurrence only), .futureEvents (this and all future), or .allEvents (all in series, if supported)
call try eventStore.save(event, span: .thisEvent) or .futureEvents
input: existing event, modified properties, span enum
output: updated event(s); throws if save fails

13. add an alarm

instantiate EKAlarm(relativeOffset: -15 * 60) for 15 minutes before
or EKAlarm(absoluteDate: alertDate) for an absolute time
call event.addAlarm(alarm) or reminder.addAlarm(alarm)
save the event/reminder
input: offset (seconds, negative = before) or absolute date
output: event/reminder with alarm attached

14. batch save multiple events/reminders

call try eventStore.save(event1, span: .thisEvent, commit: false) with commit: false
call try eventStore.save(event2, span: .thisEvent, commit: false)
after all saves, call try eventStore.commit() to flush to disk
input: multiple event/reminder objects, commit: false
output: all changes persisted in a single transaction; throws if any save fails

15. present native event editor

instantiate EKEventEditViewController()
set editor.eventStore = eventStore
set editor.editViewDelegate = self (adopt EKEventEditViewDelegate)
present from a UIViewController
implement eventEditViewController(_:didCompleteWith:) to handle .saved, .canceled, .deleted actions
input: event store instance, optional initial event to edit
output: dismissal via delegate callback with action enum

16. present event viewer

instantiate EKEventViewController()
set viewer.event = existingEvent
set viewer.allowsEditing = true/false
push onto navigation controller or present as modal
input: existing EKEvent object
output: read-only or editable view of event

17. present calendar chooser

instantiate EKCalendarChooser(selectionStyle: .multiple, displayStyle: .allCalendars, entityType: .event, eventStore: eventStore)
set chooser.showsDoneButton = true and showsCancelButton = true
set chooser.delegate = self (adopt EKCalendarChooserDelegate)
wrap in UINavigationController and present
implement delegate callbacks to capture selected calendars
input: event store instance, selection style (single or multiple), display style, entity type
output: user-selected calendar array via delegate

18. observe event store changes

register for .EKEventStoreChanged notification: NotificationCenter.default.addObserver(forName: .EKEventStoreChanged, object: eventStore, queue: .main) { [weak self] _ in self?.refreshEvents() }
inside the closure, re-fetch all events from disk (previously fetched EKEvent objects become stale)
input: none
output: closure invoked whenever calendar data changes outside your app

decision points

if authorization not yet determined: request granular access with async method. if denied, show ui directing user to settings app.

if ios 16 or earlier: fallback to legacy requestAccess(to:) callback method; do not call ios 17+ granular methods. check target deployment and branch in code.

if user has write-only access: do not attempt to read events or reminders; skip fetch operations.

if calendar is read-only: check calendar.allowsContentModifications before saving. if false, use eventStore.defaultCalendarForNewEvents instead.

if creating recurring event: decide on span (.thisEvent vs .futureEvents) before save. .thisEvent modifies only the single occurrence; .futureEvents modifies this and all later occurrences in the series.

if batching multiple saves: set commit: false on all saves except the last, or call commit() explicitly after all saves. if commit is not called, changes persist only in memory.

if event store changed notification received: re-fetch events from disk. do not rely on cached EKEvent objects; they are stale.

if time zone is unset: event will appear in the user's local timezone. set explicitly if event time should be fixed to a specific region (e.g., meeting at 9am Pacific regardless of user location).

if reminder fetch returns nil: treat as empty array; reminders not found or fetch timed out. retry with a completion handler or async/await wrapper.

if event has no alarm: event will not trigger notification. add at least one EKAlarm if notification is required.

output contract

create event: returns persisted EKEvent with unique identifier, startDate, endDate, title, calendar, optional alarms and recurrence rules. saved to eventstore on disk. identifier usable in future fetches.
fetch events: returns array of EKEvent objects, sorted by startDate ascending. recurring events are expanded to individual occurrences within the date range. empty array if no matches.
create reminder: returns persisted EKReminder with unique identifier, title, due date components, calendar, optional alarms and recurrence rules. marked incomplete by default.
fetch reminders: returns array of EKReminder objects, all incomplete. empty array if none found. fetch is asynchronous; use completion handler or continuation.
complete reminder: reminder object updated with isCompleted = true. persisted immediately.
add recurrence rule: event or reminder object now has one or more EKRecurrenceRule attached. occurrences generated on-the-fly by eventstore when fetching.
add alarm: event or reminder object has one or more EKAlarm attached. no separate persistence needed; alarm is part of event/reminder save.
batch save: all event/reminder objects persisted in a single transaction. commit() returns void on success or throws on failure.
eventkit ui presentation: user interface is system calendar editor, event viewer, or calendar chooser. dismissal invokes delegate callback with action enum (saved, canceled, deleted).
notification observer: closure invoked when event store changes. refresh ui by re-fetching events.

outcome signal

auth request shows system permission prompt; user sees "Allow" or "Don't Allow". app receives boolean result or authorization status enum.
event created: event appears in system Calendar app within seconds. calendar app shows event on correct date at correct time.
event fetched: console logs or ui displays event title, start/end time, attendees (if any).
reminder created: appears in system Reminders app. notification fires at due date if alarms attached.
recurrence rule applied: fetching events across multiple months returns multiple occurrences (e.g., weekly event fetched over 4 weeks returns 4 instances).
alarm attached: system notification appears 15 minutes (or specified offset) before event start.
batch save succeeds: multiple events appear in Calendar app; save was atomic (all-or-nothing).
eventkit ui presented: full-screen or modal system editor shown; user can edit fields and save or cancel.
notification observer fires: app re-fetches and ui refreshes when external calendar change detected (e.g., user adds event in Calendar app while your app is running).
error thrown: catch block logs reason (e.g., "calendar is read-only", "authorization denied", "network timeout"). ui shows fallback message or retry button.

eventkit-calendar

related skills

intent

inputs

procedure

1. initialize and store the event store

2. request authorization

3. check authorization status (optional, for ui state)

4. create an event

5. fetch events

6. fetch a single event by identifier

7. create a reminder

8. fetch incomplete reminders

9. mark reminder as complete

10. add recurrence rule (simple)

11. add recurrence rule (complex)

12. edit a recurring event

13. add an alarm

14. batch save multiple events/reminders

15. present native event editor

16. present event viewer

17. present calendar chooser

18. observe event store changes

decision points

output contract

outcome signal