iCare: A free 20-20-20 eye-break reminder for iPhone and Apple Watch

I'm nearsighted. Not dramatically: I drive, I ride my motorcycle, I pass the eye test for my licence. But I'm the one squinting at the departure board while everyone around me reads it without thinking, and for the past few years every check-up has ended the same way, with a prescription one notch stronger than the last. I wear glasses now.

Neither of my parents does. That turns out to matter. Myopia is partly inherited, and children with no nearsighted parents are the group least likely to develop it: under ten percent in the Orinda study, against thirty to forty percent for kids with two nearsighted parents. I was in the lucky group and got it anyway. When I told the optometrist at Pearle how I grew up, the reaction was a nod rather than surprise. A Nintendo DS held about twenty centimetres from my face from the age of six, and after that every screen there was, always close, always for hours. The most likely cause, in the optometrist's words.

Nobody can prove that for one person. But the numbers for the population as a whole are not subtle, and I'll get to them below.

The advice I got was the one optometrists have given for years: every 20 minutes, look at something 20 feet away for 20 seconds. The 20-20-20 rule. Knowing it was never the problem. Remembering to do it while I'm deep in a problem is.

What the research actually says

I went looking for the studies rather than taking one optometrist's word for it. Three findings stuck.

Near work is linked to myopia, and the dose matters. A 2015 meta-analysis in PLoS ONE pooled 27 studies covering about 25,000 children aged 6 to 18. Children who did more near work had 14 percent higher odds of being myopic, and every extra diopter-hour of near work per week added about 2 percent. In the weighting those studies used, reading counts triple and screens double. A handheld console at twenty centimetres is about as near as near work gets.

Screens specifically, too. A 2021 review in The Lancet Digital Health went through 33 studies on smart device use. Screen time on phones and tablets came with roughly 26 percent higher odds of myopia, and combined with computer use, 77 percent. The authors are careful to say most of those studies measured screen time badly, by questionnaire, so hold the exact numbers loosely. The direction is consistent.

This is a global trend, not a personal quirk. Holden and colleagues estimated in 2016 that 23 percent of the world was myopic in 2000 and projected close to 50 percent by 2050, about 4.8 billion people. East Asia, where screen-heavy schooling started earliest, is already well past half.

The flip side is just as well documented. The Sydney Myopia Study found that twelve-year-olds who spent more time outdoors were less likely to be myopic, and the effect held even for kids who also did a lot of reading. It wasn't sport that mattered, it was daylight. The leading theory is that bright light drives retinal dopamine, which slows the eye's elongation.

The growing eye is the key phrase there. Nearly all of this research is about children, because that's when the eyeball is still changing shape. Whether near work keeps nudging an adult prescription is less settled. Mine keeps moving, so I'm not inclined to wait for the definitive paper.

What a 20-minute timer can and can't fix

I want to be honest about this, because the App Store is full of apps that aren't. There is no evidence that the 20-20-20 rule slows myopia. What it does is treat the strain: the dry eyes, the headaches, the fog at four in the afternoon.

Even that has only really been tested once. In a 2023 study in Contact Lens and Anterior Eye, 29 symptomatic computer users got webcam-driven 20-20-20 reminders for two weeks. Eye strain and dry-eye symptoms dropped. One week after the reminders stopped, the improvement was gone. That last part is the interesting bit: the rule works for as long as something keeps reminding you, and not a day longer. Which is an argument for a tool that stays on, not for willpower.

So iCare is the part of my eye care I can automate. The walk outside at lunch is the part I can't.

Every existing app wanted my money or my patience

I tried a handful of 20-20-20 apps on the App Store. Some were fine but charged a subscription for what is essentially a repeating timer. Others were bloated with gamification, streaks, wellness dashboards, and meditation upsells bolted onto what should be a 20-second break. A few were genuinely abandoned, crashing on launch or stuck on an iOS version from two years ago.

None of the ones I found supported Apple Watch. That was the real dealbreaker. If I'm deep in code and my phone is on silent across the room, a notification I never see doesn't help. A gentle tap on my wrist actually gets my attention without breaking flow.

So I built one.

What it does

iCare does exactly one thing: remind you to take eye breaks on a schedule, then count you through them.

The home screen shows a circular timer counting down to your next break. When it fires, you get a notification with three options: start the break, snooze it, or skip it entirely. Tapping "start" opens a 20-second countdown that tells you to look at something in the distance. That's the whole interaction.

Beyond that:

• Configurable interval from 15 to 45 minutes, so you can tune it to how you work
• Adjustable break duration between 10 and 30 seconds
• Schedule controls with active hours and weekdays-only mode, so it stays quiet evenings and weekends
• Pause, snooze, skip so you're always in control without disabling the whole thing
• Today's history showing completed and skipped breaks at a glance

Apple Watch is what makes it actually useful

The Watch companion was the main reason I built this instead of just setting a recurring timer. Reminders arrive as a haptic tap on your wrist, subtle enough that it doesn't interrupt a meeting or a conversation, but noticeable enough that you won't miss it.

You can start the countdown directly from the Watch notification. The phone and Watch stay in sync through WatchConnectivity, so starting a break on one device reflects on the other. Settings sync too, so you configure once and both devices stay aligned.

How it's built

iCare is a native SwiftUI app targeting iOS 17 and watchOS 10. I wanted it lean, so there are zero third-party Swift packages. Everything is built on Apple frameworks only.

The architecture is straightforward:

• AppState is the central observable model that owns scheduling, break state, notifications, and Watch sync
• ReminderEngine handles the interval math: next fire dates, active hours, weekday filtering, snooze logic
• NotificationCoordinator manages UserNotifications with actionable categories (Start, Snooze, Skip)
• WatchSyncManager bridges iPhone and Watch state via WatchConnectivity
• SettingsStore persists preferences in UserDefaults through a shared App Group so both targets read the same data

There's also a Focus filter integration using App Intents. You can override reminder behavior per Focus mode, so your "Do Not Disturb" or "Sleep" focus can automatically pause reminders without you touching anything.

iCare/                 iPhone app (SwiftUI)
  App/                 Entry point and root navigation
  Features/            Home, Countdown, History, Settings, Onboarding
  Intents/             Focus filter (SetFocusFilterIntent)

iCareWatch/            watchOS app
  App/                 Entry point
  Features/            Home, Countdown, Notification scene

Shared/                Code shared between iPhone and Watch
  Models/              AppState, settings, break records
  Services/            ReminderEngine, NotificationCoordinator, WatchSyncManager
  DesignSystem/        Colors, typography, shared UI components

The project uses XcodeGen for project generation and Fastlane with GitHub Actions for CI/CD. Pushing a version tag triggers the full pipeline: code signing via Match, building via Gym, and uploading to App Store Connect.

Lessons learned

WatchConnectivity is more finicky than the documentation suggests. The Watch and phone don't always have an active session at the same time, and transferUserInfo queues messages that can arrive out of order or much later than expected. I ended up using sendMessage for real-time commands (like "start break now") and updateApplicationContext for settings sync, which overwrites rather than queues. Getting that split right took some trial and error.

Local notifications on iOS also have limits I didn't expect. You can only schedule 64 pending notifications at a time, which sounds like a lot until you realize a 20-minute interval across an 8-hour workday burns through 24 per day. The engine pre-schedules a rolling window and refreshes whenever the app comes to the foreground.

No accounts, no tracking, no subscription

iCare collects nothing. There's no analytics SDK, no backend, no account creation. Your settings and break history live in UserDefaults on your device and sync to your Watch through Apple's encrypted WatchConnectivity protocol. The privacy policy is short because there's nothing to disclose.

Charging a subscription for a timer that runs locally on your phone feels wrong. iCare is free.

View on GitHub