Tracking Daily Completion for Multi-Day Calendar Events with EventKit

I released Calendar ToDo v2.1.0.

In this update, I added support for recording completion per day for calendar events that span multiple days.

Calendar ToDo is an iOS app that reads existing calendar events with EventKit and lets users record things like "done", "partially done", and reflections without editing the original calendar event.

https://apps.apple.com/us/app/calendar-todo/id6756511434

The Problem: A Multi-Day Event Is Not Always One Unit of Action

Calendar ToDo lets users attach completion records to calendar events.

But while using the app, I noticed that the unit of a calendar event does not always match the unit of actual activity.

For example:

Travel
Business trips
Training sessions
Exam periods
Multi-day workshops
Work that takes several days

These are often registered as a single calendar event.

Travel: May 1 - May 3

But the actual experience can be different each day.

May 1 went as planned
May 2 only moved forward a little
May 3 only got partially done because I was tired

If the app stores only one completion state for the whole trip, it cannot show what happened on each day.

The goal of Calendar ToDo is not to preserve the calendar event itself, but to preserve how the user acted in relation to that event.

So in v2.1.0, I started treating multi-day events not just as a single calendar event, but as separate daily completion targets.

What Changed in v2.1.0

In v2.1.0, multi-day calendar events can have separate completion records for each day.

Conceptually, it looks like this:

Calendar event
- Travel: May 1 - May 3

Calendar ToDo records
- Travel on May 1: Done
- Travel on May 2: Partially done
- Travel on May 3: Half done

The calendar event remains a single event.

On the Calendar ToDo side, records are stored separately for each display date.

This makes it possible to add daily execution results without splitting the calendar event or changing its title.

Why I Do Not Split Calendar Events

The most important design decision was to not modify the user's calendar.

Calendar ToDo reads calendar events, but completion records are stored separately inside the app.

Even when handling a multi-day event, the app does not split the EKEvent or rewrite the original event.

EventKit
- EKEvent: Travel, May 1 - May 3

Calendar ToDo
- DailyCompletion: record for May 1
- DailyCompletion: record for May 2
- DailyCompletion: record for May 3

For work calendars and shared calendars, modifying events can be risky or simply unwanted.

So Calendar ToDo keeps the calendar read-only and stores "the record for this event on this day" inside the app.

Implementation Idea

Instead of displaying an EKEvent as a single item, the app expands it into display units for each date.

For example, if an event runs from May 1 to May 3, the internal display unit can be represented like this:

struct DailyEvent {
    let event: EKEvent
    let displayDate: Date
}

EKEvent represents the original calendar event, and displayDate represents the day being recorded in Calendar ToDo.

That means the same EKEvent can become different recording targets when the display date is different.

EKEvent(Travel) + 2026-05-01
EKEvent(Travel) + 2026-05-02
EKEvent(Travel) + 2026-05-03

With this structure, the UI can still display the event like a normal calendar item, while saving completion records separately per day.

Expanding a Multi-Day Event into Dates

A multi-day event is expanded from its start date to its end date, creating one DailyEvent per display date.

Here is a simplified implementation example:

func displayDates(for event: EKEvent, calendar: Calendar) -> [Date] {
    let start = calendar.startOfDay(for: event.startDate)

    let displayEndDate: Date
    if event.isAllDay,
       let adjustedEndDate = calendar.date(byAdding: .second, value: -1, to: event.endDate) {
        displayEndDate = adjustedEndDate
    } else {
        displayEndDate = event.endDate
    }

    let end = calendar.startOfDay(for: displayEndDate)

    var dates: [Date] = []
    var current = start

    while current <= end {
        dates.append(current)

        guard let next = calendar.date(byAdding: .day, value: 1, to: current) else {
            break
        }

        current = next
    }

    return dates
}

For all-day events, the end date can behave like a date boundary. If it is expanded as-is, the event may appear one day longer than expected.

So for all-day events, the display end date is adjusted before converting the event into day-based display units.

Completion Records Use "Event + Display Date"

To save completion per day, the key must include not only the original event, but also the day being recorded.

Conceptually, the key looks like this:

struct DailyCompletionKey: Hashable {
    let calendarItemIdentifier: String
    let occurrenceStartDate: Date
    let occurrenceEndDate: Date
    let displayDate: Date
}

The important part is displayDate.

Even for the same multi-day event, the record for May 1 and the record for May 2 should be stored separately.

Travel, May 1 - May 3

- displayDate: May 1 -> Done
- displayDate: May 2 -> Partially done
- displayDate: May 3 -> Half done

Also, when considering recurring events and event updates, I do not want to depend only on eventIdentifier.

Calendar ToDo has always treated "this event on this day" as an important concept. For multi-day events, "which day inside this event" becomes even more important.

In the actual implementation, recurring events, event changes, and time zones are also taken into account.

UI Considerations

From the user's point of view, a multi-day event should feel almost the same as a normal event.

So I did not add a special workflow like "split this multi-day event". Instead, the event appears naturally in the event list for each day.

For example, the May 1 screen shows Travel as the May 1 item, and the May 2 screen shows Travel as the May 2 item.

Each day has an independent completion state.

May 1
- Travel: Done

May 2
- Travel: Partially done

May 3
- Travel: Not recorded yet

With this behavior, users can record the day's action without thinking about splitting a multi-day calendar event.

Where This Helps

This feature is useful for events where the experience changes from day to day.

Travel and Business Trips

Travel and business trips often have different phases: moving, working, resting, and wrapping up.

Daily records make it easier to look back and see what happened on each day, instead of only knowing that the trip existed.

Exam Periods and Training

Exam periods and training sessions also vary by day.

Even if they are registered as one calendar event, it can be useful to record each day's progress separately.

Long-Running Tasks

This also works for personal development, writing articles, studying for a qualification, or any task that takes several days.

Even when the task is registered as one large calendar event, daily progress records make it easier to see that the work was moving forward little by little.

What I Learned

This update reminded me that a calendar event is not always the smallest unit of execution.

On a calendar, an event may be one item. But in real life, people often reflect on what happened day by day.

With Calendar ToDo, I want to use the calendar not only as a schedule, but also as an execution log of what I actually did.

To make that work, recording by event is not always enough. Sometimes the app needs to record by day.

This looks like a small feature, but it is an important improvement for the direction of Calendar ToDo.

What I Want to Improve Next

I want to make recorded data easier to review.

Weekly reviews
Monthly achievement summaries
Progress by event
Better visibility for partially completed events
Reports that help users understand their own rhythm

Calendar ToDo is not an app for adding more plans. It is an app for using existing calendar events to preserve what you actually did.

Putting events on a calendar does not automatically preserve how you spent your time.

Calendar ToDo aims to let users quietly accumulate daily action records without changing the original calendar.

Summary

In Calendar ToDo v2.1.0, I added support for recording completion per day for multi-day calendar events.

The original calendar event is not split
EventKit events remain read-only
Calendar ToDo stores records with "event + display date"
Multi-day events can have different execution results for each day

Even if a plan is one calendar event, the actual result can be different each day.

By preserving those differences, the calendar becomes more useful when looking back.