feat(timeline): optional hour separator lines in week & day view

Add a showHourLines preference (default off — the existing clean look).
When on, the week and day timelines draw a faint outline-variant line at
each hour boundary, sitting over the column background but beneath event
blocks. The toggle is provided app-wide via LocalShowHourLines and applied
through a reusable hourSeparatorLines() modifier.

Closes #5 (Codeberg)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.planning/ROADMAP.md

@@ -230,7 +230,7 @@ pass on the existing controls; new toggles ride in with their own features.
 
 **Tier 3 — platform reach (depends on Tier 2)**
 7. ~~Home-screen widget — built on the agenda data source from #6~~ *(done, v2.5.0 — agenda + month widgets)*
-8. App shortcuts: ~~launcher long-press → New event~~ *(done, v2.5.0)*; optional quick-settings tile still open
+8. App shortcuts: ~~launcher long-press → New event~~ *(done, v2.5.0)*; ~~quick-settings tile~~ *(done, v2.8.0 — "New event" QS tile)*
 
 **Tier 4 — reliability, data-safety & interop** *(re-ranked 2026-06-17)*
 9. **Reminders — defaults + delivery reliability** *(shipped v2.6.0)* — global
@@ -251,37 +251,38 @@ pass on the existing controls; new toggles ride in with their own features.
     decision (snooze must re-fire an alarm).
 
 **Tier 5 — close the read/write gap on the event model** *(opened 2026-06-22)*
-12. **Attendee editing** *(next — promoted from the gated "Locations & People"
-    bucket, owner says high-importance 2026-06-22)* — attendees are already
-    *read* (queried, mapped, shown on the detail screen since v0.6) but the
-    event form can't *write* them, the last big read-only gap in the event
-    model. Add an attendees section to `EventEditScreen` / `EventForm`: add by
-    typed email (contact-picker entry can follow later), edit/remove rows, set
-    role (required / optional) — writing `CalendarContract.Attendees` rows on
-    insert + dirty-checked update, mirroring the reminders-diff pattern.
-    **Caveat to resolve first:** writing `Attendees` rows triggers sync-adapter
-    *invitation* behavior that differs by backend (Google auto-emails invites;
-    DAVx5/CalDAV writes the `ATTENDEE` property and lets the server decide) —
-    decide and document what Calendula promises before building. Full sketch in
-    "Attendee editing" under Locations & People below.
+12. **Attendee editing** *(shipped — merged into release/v2.8.0, `feat/attendee-editing`
+    MR !29 / commit `b0f34ff`, 2026-06-22)* — closed the last big read-only gap in
+    the event model: attendees were already *read* (queried, mapped, shown on the
+    detail screen since v0.6) and are now *writable* from the form. An attendees
+    section on `EventEditScreen` / `EventForm` adds by typed email **or** the
+    no-permission contact picker, edits/removes rows, and sets role (required /
+    optional) — writing `CalendarContract.Attendees` rows on insert + dirty-checked
+    update, mirroring the reminders-diff pattern. The sync-adapter *invitation*
+    caveat was **settled record-only** (Calendula never sends invites; the backend
+    decides delivery) — full sketch + decision in "Attendee editing" under Locations
+    & People below.
 
 **Gated — explicit go/no-go before any work (mostly INTERNET-permission calls)**
 - Remote calendar create/edit (re-implements DAVx5; INTERNET + credential storage)
-- Locations & People — contact address picker (no-permission, one-shot) is the safe entry; OSM autocomplete needs INTERNET
+- Locations & People — the no-permission contact pickers already shipped (location v2.8.0, attendee email v2.8.0); what remains gated is OSM autocomplete (needs INTERNET)
 - Move event to another calendar — sync-adapter minefield (copy+delete model)
 
 **Bottom — deprioritised, not important**
 - Duplicate event (detail action → prefilled create form) — moved here
   2026-06-17; cheap but low value, pick up only if asked
 
-**Unranked / fill-in** — pinch-to-zoom time scale, tablet/foldable layouts,
-full-text search. Pulled in opportunistically, not sequenced.
+**Unranked / fill-in** — pinch-to-zoom time scale, tablet/foldable layouts.
+Pulled in opportunistically, not sequenced.
 
 Tier 4 is now fully shipped (#9 reminders defaults v2.6.0, #10 `.ics`
-export/import v2.7.0, #11 snooze/dismiss in release/v2.8.0; drag-drop rejected).
-**Next committed work is Tier 5 #12 — attendee editing** (the last read-only gap
-in the event model). After it: the theme-group ideas and Tier 2/3 leftovers
-(quick-settings tile, now-line, week numbers in month, full-text search).
+export/import v2.7.0, #11 snooze/dismiss in release/v2.8.0; drag-drop rejected),
+and Tier 5 #12 — attendee editing — shipped in release/v2.8.0, closing the last
+read-only gap in the event model. v2.8.0 also cleared most Tier 2/3 leftovers —
+full-text search, the "New event" Quick Settings tile, and the now-line all
+shipped there. **No tier work is currently committed as next;** the remaining
+candidates are unscheduled theme-group ideas (pinch-to-zoom, tablet/foldable,
+accessibility pass) plus the gated go/no-go items.
 
 ## Navigation & views
 
@@ -291,24 +292,22 @@ in the event model). After it: the theme-group ideas and Tier 2/3 leftovers
 - Agenda view (fourth view: upcoming events grouped by day; also the
   natural data source for a future widget)
 - Jump to date — drawer date picker (un-cut from V1)
-- Current-time "now" line in day/week — standard in every calendar, cheap,
-  currently absent. Daily-driver polish.
-- Week numbers in the **month** grid — week view already shows the badge
-  (`WeekNumberBadge`, `WeekScreen.kt`); extend to month for ISO/European users.
+- ~~Current-time "now" line in day/week~~ **shipped v2.8.0**
+- Week numbers in the **month** grid — **rejected** (owner decision): clutters
+  the view and shrinks the day cells; the badge stays week-view-only.
 - Pinch-to-zoom time scale in day/week
 - Tablet / foldable layouts *(was v3.0)*
-- Full-text search *(was v3.0)* — promote out of "fill-in": for a daily driver
-  with real event history, finding an event is core completeness, not optional.
+- ~~Full-text search~~ **shipped v2.8.0** — for a daily driver with real event
+  history, finding an event is core completeness, not optional.
 
 ## Event editing & creation
 
 - Duplicate event (detail action → prefilled create form)
-- **Per-event color** (`Events.EVENT_COLOR`, OptionCard picker in the form)
-  *(next)* — chosen to follow the in-progress tap-to-create + calendar
-  management work: reuses the color-picker component and palette plumbing
-  being built for local calendar management, and finishes the create/edit
-  theme. `EVENT_COLOR` / `EVENT_COLOR_KEY` from the calendar's color list
-  (`Colors` table, `TYPE_EVENT`); falls back to the calendar color when unset.
+- ~~**Per-event color**~~ *(shipped v2.4.0)* — `EVENT_COLOR` / `EVENT_COLOR_KEY`
+  from the calendar's color list (`Colors` table, `TYPE_EVENT`), OptionCard
+  picker in the form, falling back to the calendar color when unset. Reused the
+  color-picker component and palette plumbing from local calendar management and
+  finished the create/edit theme.
 
 ## Calendars & accounts
 
@@ -337,7 +336,63 @@ in the event model). After it: the theme-group ideas and Tier 2/3 leftovers
   `.ics` file (SAF); restore is the bulk-import path (pick a calendar, dedup by
   UID). Closed the silent data-loss gap.
 
-## Reminders — defaults & delivery reliability *(implemented 2026-06-17, `feat/default-reminders` — pending on-device review)*
+### Disable a calendar in-app *(captured 2026-06-25)*
+
+A second, heavier visibility level **above** the existing per-view filter. Today
+the drawer's calendar filter (`hiddenCalendarIds` in `CalendarPrefs`) only hides
+a calendar's *events* from the month/week/day/agenda views — the calendar itself
+still clutters the drawer filter list, the event-form calendar picker, and the
+import target picker. "Disable" removes a calendar from the app's surfaces
+entirely; "hide" stays the lightweight, frequently-toggled control.
+
+**Two-level model (both kept):**
+- **Hidden** (existing) — `hiddenCalendarIds`; a quick per-view checkbox in the
+  drawer. Toggles events on/off in the views; the calendar stays listed
+  everywhere. Operates only over the *enabled* calendars.
+- **Disabled** (new) — the calendar is gone from the app: not in the drawer
+  filter list, not in the event-form picker, not in the import picker, and its
+  events never appear (it's gated out of `instances()` like a hidden one). It
+  remains visible **only** in Settings → Calendars, where the enable/disable
+  toggle lives, so it can be brought back.
+
+**Storage — app-side (DataStore), mirrors the hidden set.** Add
+`disabledCalendarIds: Set<Long>` + `setDisabledCalendarIds(...)` to
+`CalendarPrefs` (comma-separated string key, same shape as `hiddenCalendarIds`).
+**Does not touch** `CalendarContract.Calendars.VISIBLE` / `SYNC_EVENTS` — purely
+a Calendula-local preference, so other calendar apps are unaffected and the sync
+adapters stay out of it (privacy-clean, reversible).
+
+**Where the disabled set is applied:**
+- `CalendarRepositoryImpl.instances()` + `searchEvents()` — exclude
+  `calendarId ∈ (hidden ∪ disabled)` so a disabled calendar's events never show
+  and aren't searchable. (`repository.calendars()` itself stays unfiltered/raw —
+  the screens that need everything still get everything.)
+- `FilterViewModel.state` — drop disabled calendars from the drawer filter list
+  (you can't hide/show what's disabled).
+- `EventEditViewModel.writableCalendars` — exclude disabled, so you can't create
+  into a calendar you've removed from the app. Handle the last-used-calendar
+  preselect falling on a now-disabled calendar (fall back to first enabled
+  writable).
+- `ImportViewModel` — exclude disabled from the import target list.
+- `CalendarsScreen` / `CalendarsViewModel` — the **only** surface that lists
+  disabled calendars; add `setDisabled(id, Boolean)` and a per-calendar toggle.
+
+**UI — Settings → Calendars (no new tab).** Add an enable/disable control to each
+row on the existing `CalendarsScreen` (both the local and the synced/read-only
+groups — disabling is an app-side view choice, independent of write access).
+Disabled rows render visibly de-emphasised (dimmed) but keep the toggle so
+they're re-enableable. Follow the project dialog/list conventions (M3 grouped
+list, `option-card-modal-style-default` if a confirm/selection surface is needed).
+
+**Decided behaviour:**
+- All calendars disabled → views show the existing empty state.
+- A disabled calendar that still holds events: events simply vanish from
+  views/search until re-enabled (no data touched — it's a filter, not a delete).
+- Deep links / notifications pointing at an event in a disabled calendar still
+  open its detail screen — detail is a direct id lookup, not an `instances()`
+  query, so disabling never strands an existing link.
+
+## Reminders — defaults & delivery reliability *(shipped v2.6.0; built on `feat/default-reminders`)*
 
 Two themes bundled because both are "make reminders trustworthy" — the core of
 the "Calendula is your only calendar app" promise.
@@ -414,18 +469,20 @@ it directly undermines the feature's premise, so it rides in here.
   settings so users can verify delivery on their specific OEM (Samsung / Xiaomi
   are notorious for suppressing it).
 
-### Open decisions (resolve before building)
+### Decisions made (as shipped in v2.6.0)
 
-1. Self-schedule via `AlarmManager` vs trust the provider broadcast
-   (reliability vs simplicity + battery cost).
-2. All-day reminder representation (minutes-before vs absolute time-of-day).
-3. Where per-calendar overrides live in the UI (rows on the Calendars screen vs
-   a list inside the Notifications sub-page).
+1. **Provider broadcast kept** — did not self-schedule via `AlarmManager`; the
+   battery-optimisation exemption is the reliability lever (simplicity + battery
+   cost won over the exact-alarm subsystem).
+2. **All-day reminders = minutes-before-midnight** (day-scale presets); absolute
+   time-of-day ("9am the day before") deferred — see the deferred list above.
+3. **Per-calendar overrides live in the Notifications sub-page** (override list),
+   governing timed events only.
 
-### Later (round two)
+### Round two
 
-- Snooze + dismiss actions on the notification (snooze needs an
-  exact-alarm / WorkManager decision) — Tier 4 #13.
+- ~~Snooze + dismiss actions on the notification~~ *(shipped in release/v2.8.0,
+  Tier 4 #11)* — snooze re-fires a snooze-only exact alarm.
 
 ## Sharing & interop
 
@@ -438,8 +495,8 @@ it directly undermines the feature's premise, so it rides in here.
 ## Platform & launchers
 
 - ~~Home-screen widget~~ **shipped v2.5.0** — agenda + month widgets
-- ~~App shortcuts (launcher long-press → New event)~~ **shipped v2.5.0** —
-  optional quick-settings tile still open
+- ~~App shortcuts (launcher long-press → New event)~~ **shipped v2.5.0**
+- ~~"New event" Quick Settings tile~~ **shipped v2.8.0**
 
 ## Quality & reliability
 
@@ -455,9 +512,10 @@ it directly undermines the feature's premise, so it rides in here.
 Beyond classic calendar-client scope; discussed, deliberately not planned
 in detail yet:
 
-- **Contact address picker** for the location field via the system picker
-  (`ACTION_PICK` on postal addresses) — one-shot, needs no READ_CONTACTS,
-  fits the privacy story. Same mechanism later for picking emails.
+- ~~**Contact address picker** for the location field via the system picker
+  (`ACTION_PICK`)~~ **shipped v2.8.0** — one-shot, needs no READ_CONTACTS, fits
+  the privacy story. The same no-permission mechanism was then reused for the
+  attendee email picker (v2.8.0).
 - **OSM address autocomplete** in the location field (type "Brandenburger
   Tor" → tap suggestion → resolved address inserted). Backend would be
   Photon (Nominatim's public policy forbids autocomplete). **Requires the

CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.10.0] — 2026-06-25
+
+### Added
+- Turn a calendar off across the whole app. Settings → Calendars now has a
+  switch on every calendar — both your own and synced ones. Switching one off
+  removes it everywhere: its events disappear from all views and search, and it
+  drops out of the drawer's hide/show filter, the event-form calendar picker and
+  the import target picker. Unlike hiding (the quick per-view checkbox in the
+  drawer), a disabled calendar leaves the app entirely until you turn it back on.
+  Nothing is deleted and no other app is affected — it's a Calendula-only view
+  choice — so you can re-enable it any time from the same screen, where disabled
+  calendars stay listed but dimmed.
+- An optional way to support development. Settings → About now has a "Support
+  development" button that opens Ko-fi in your browser. It's a plain donation
+  link with no perks attached, and it needs no new permissions — Calendula still
+  has no internet access of its own and just hands the link to your browser.
+
 ## [2.9.0] — 2026-06-25
 
 ### Added

README.md

@@ -15,6 +15,12 @@ Reads, writes, and reminds — on top of the system calendar, with zero network
 <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="MIT License"></a>
 </p>
 
+<p>
+<a href="https://f-droid.org/packages/de.jeanlucmakiola.calendula/"><img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="56"></a>
+&nbsp;
+<a href="https://ko-fi.com/jeanlucmakiola"><img src="https://storage.ko-fi.com/cdn/brandasset/v2/support_me_on_kofi_badge_beige.png" alt="Support me on Ko-fi" height="56"></a>
+</p>
+
 <p>
 <img src="fastlane/metadata/android/en-US/images/phoneScreenshots/01-week.png" width="19%" alt="Week view">&nbsp;
 <img src="fastlane/metadata/android/en-US/images/phoneScreenshots/02-month.png" width="19%" alt="Month view">&nbsp;
@@ -68,13 +74,20 @@ database, no sync stack reinvented.
 
 ## 📦 Install
 
-Calendula ships through a self-hosted F-Droid repository; every version tag
-is built, signed, and published there automatically.
+### F-Droid (recommended)
 
-1. Install an F-Droid client ([F-Droid](https://f-droid.org), Droid-ify, Neo
-   Store, …).
-2. Add the repository — open this link on your phone, or paste it under
-   *Settings → Repositories → Add*:
+Calendula is on the **official [F-Droid](https://f-droid.org) repository** —
+just search for **Calendula** in any F-Droid client, or
+[install it from f-droid.org](https://f-droid.org/packages/de.jeanlucmakiola.calendula/).
+
+### Self-hosted repo (latest builds)
+
+New versions are built, signed, and published to a self-hosted repository the
+moment each tag lands — usually a few days ahead of the official repo, which
+rebuilds on F-Droid's own schedule. Add it for the freshest builds:
+
+1. In your F-Droid client, open *Settings → Repositories → Add* (or open the
+   link below on your phone):
 
    ```
    https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo?fingerprint=C2C0640402BF458FC0ED957AF0B37AA4C14022E72F89CE90B5965B458CF73425
@@ -84,36 +97,16 @@ is built, signed, and published there automatically.
    fingerprint (SHA-256):
    `C2C0 6404 02BF 458F C0ED 957A F0B3 7AA4 C140 22E7 2F89 CE90 B596 5B45 8CF7 3425`</sub>
 
-3. Refresh, search for **Calendula**, install. Updates arrive like any
-   other F-Droid app.
+2. Refresh, search for **Calendula**, install.
 
-Alternatively, build from source — see below.
+Both channels share the same signing key, so you can switch between them
+without reinstalling. Or build from source — see below.
 
-## 🛠 Building
+## 📚 Documentation
 
-Requires Android SDK 36+ and JDK 17. The Gradle wrapper is checked in:
-
-```bash
-./gradlew assembleDebug   # debug APK
-./gradlew test            # JVM unit tests
-./gradlew lint            # Android lint
-```
-
-If your default JDK is not 17, set `JAVA_HOME` explicitly.
-
-## 🏗 Architecture
-
-Single-activity Compose app, layered `UI → Repository → DataSource →
-CalendarContract`, observer-driven refresh, JVM-first tests. The full tour —
-including the recurring-write and reminder pipelines — lives in
-[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
-
-## 🗺 Roadmap
-
-Shipped: read (v1.0), write (v1.1–v2.0), reminder delivery (v1.4).
-Next up: power-user features — widget, search, tablet layouts. The living
-roadmap is in [.planning/ROADMAP.md](.planning/ROADMAP.md), the release
-history in [CHANGELOG.md](CHANGELOG.md).
+- **[Building from source](docs/BUILDING.md)** — requirements and Gradle tasks
+- **[Architecture](docs/ARCHITECTURE.md)** — the layered design and key pipelines
+- **[Roadmap](.planning/ROADMAP.md)** — what's shipped and what's next
 
 ## 📜 License
 

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // which builds this version and then creates the matching vX.Y.Z tag +
         // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
         // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 20900
-        versionName = "2.9.0"
+        versionCode = 21000
+        versionName = "2.10.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -9,10 +9,13 @@ import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -20,7 +23,10 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.ui.RootScreen
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
@@ -81,19 +87,31 @@ class MainActivity : AppCompatActivity() {
                 ThemeMode.LIGHT -> false
                 ThemeMode.DARK -> true
             }
+            // The app-wide clock convention: the time-format preference resolved
+            // against the device's 24-hour system setting, provided once here so
+            // every time label reads it via LocalUse24HourFormat.
+            val context = LocalContext.current
+            val use24Hour = remember(settings.timeFormat, context) {
+                settings.timeFormat.is24Hour(android.text.format.DateFormat.is24HourFormat(context))
+            }
             CalendulaTheme(
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
             ) {
-                RootScreen(
-                    modifier = Modifier.fillMaxSize(),
-                    requestedDetailKey = requestedDetailKey,
-                    onDetailKeyConsumed = { requestedDetailKey = null },
-                    widgetNavRequest = requestedNav,
-                    onWidgetNavConsumed = { requestedNav = null },
-                    requestedImportUri = requestedImportUri,
-                    onImportConsumed = { requestedImportUri = null },
-                )
+                CompositionLocalProvider(
+                    LocalUse24HourFormat provides use24Hour,
+                    LocalShowHourLines provides settings.showHourLines,
+                ) {
+                    RootScreen(
+                        modifier = Modifier.fillMaxSize(),
+                        requestedDetailKey = requestedDetailKey,
+                        onDetailKeyConsumed = { requestedDetailKey = null },
+                        widgetNavRequest = requestedNav,
+                        onWidgetNavConsumed = { requestedNav = null },
+                        requestedImportUri = requestedImportUri,
+                        onImportConsumed = { requestedImportUri = null },
+                    )
+                }
                 pendingCrashReport?.let { report ->
                     CrashReportDialog(
                         report = report,

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt

@@ -14,6 +14,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
@@ -55,11 +56,12 @@ class CalendarRepositoryImpl @Inject constructor(
             .reQuery { dataSource.calendars() }
             .flowOn(io)
 
-    // Instances are filtered by the app-side hidden-calendar set (M3): an event
-    // is dropped whenever the user has hidden its calendar. Re-runs when the
-    // provider ticks *or* the hidden set changes — toggling a calendar in the
-    // filter sheet updates every view immediately. [calendars] stays unfiltered
-    // so the filter sheet can list and re-enable hidden calendars.
+    // Instances are filtered by the app-side hidden ∪ disabled calendar sets
+    // (M3): an event is dropped whenever the user has hidden *or* disabled its
+    // calendar. Re-runs when the provider ticks *or* either set changes —
+    // toggling a calendar in the filter sheet or the calendar manager updates
+    // every view immediately. [calendars] stays unfiltered so those screens can
+    // list and re-enable hidden/disabled calendars.
     override fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>> =
         combine(
             ticks
@@ -71,10 +73,17 @@ class CalendarRepositoryImpl @Inject constructor(
                     )
                 },
             prefs.hiddenCalendarIds,
-        ) { instances, hidden ->
-            if (hidden.isEmpty()) instances
-            else instances.filterNot { it.calendarId in hidden }
-        }.flowOn(io)
+            prefs.disabledCalendarIds,
+        ) { instances, hidden, disabled ->
+            val excluded = hidden + disabled
+            if (excluded.isEmpty()) instances
+            else instances.filterNot { it.calendarId in excluded }
+        }
+            // hidden and disabled both derive from one DataStore, so toggling
+            // either makes both re-emit and combine briefly surfaces the same
+            // list twice — collapse the duplicate so views don't re-render for it.
+            .distinctUntilChanged()
+            .flowOn(io)
 
     override suspend fun eventDetail(eventId: Long): EventDetail = withContext(io) {
         dataSource.eventDetail(eventId) ?: throw NoSuchEventException(eventId)
@@ -82,9 +91,9 @@ class CalendarRepositoryImpl @Inject constructor(
 
     override suspend fun searchEvents(query: String): List<EventInstance> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
-        val hidden = prefs.hiddenCalendarIds.first()
+        val excluded = prefs.hiddenCalendarIds.first() + prefs.disabledCalendarIds.first()
         dataSource.searchEvents(query)
-            .let { if (hidden.isEmpty()) it else it.filterNot { e -> e.calendarId in hidden } }
+            .let { if (excluded.isEmpty()) it else it.filterNot { e -> e.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt

@@ -39,6 +39,31 @@ class CalendarPrefs @Inject constructor(
         }
     }
 
+    /**
+     * App-side preference for "calendars the user has disabled in this app" — a
+     * heavier level than [hiddenCalendarIds]. A disabled calendar is removed from
+     * every surface (drawer filter, event-form picker, import picker) and its
+     * events never appear; it stays listed only in Settings → Calendars so it can
+     * be re-enabled. Stored exactly like the hidden set; never touches the
+     * system's VISIBLE/SYNC_EVENTS flags, so other calendar apps are unaffected.
+     */
+    val disabledCalendarIds: Flow<Set<Long>> = store.data.map { prefs ->
+        prefs[DISABLED_IDS_KEY].orEmpty()
+            .split(',')
+            .mapNotNull { it.trim().toLongOrNull() }
+            .toSet()
+    }
+
+    suspend fun setDisabledCalendarIds(ids: Set<Long>) {
+        store.edit { prefs ->
+            if (ids.isEmpty()) {
+                prefs.remove(DISABLED_IDS_KEY)
+            } else {
+                prefs[DISABLED_IDS_KEY] = ids.sorted().joinToString(",")
+            }
+        }
+    }
+
     /**
      * The calendar the user last created an event in; preselected in the
      * event form. Null until the first event is created.
@@ -53,6 +78,7 @@ class CalendarPrefs @Inject constructor(
 
     companion object {
         internal val HIDDEN_IDS_KEY = stringPreferencesKey("hidden_calendar_ids")
+        internal val DISABLED_IDS_KEY = stringPreferencesKey("disabled_calendar_ids")
         internal val LAST_USED_CALENDAR_KEY = longPreferencesKey("last_used_calendar_id")
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -22,6 +22,22 @@ enum class ThemeMode { SYSTEM, LIGHT, DARK }
 /** Week-start override. AUTO derives the first day from the active locale. */
 enum class WeekStartPref { AUTO, MONDAY, SUNDAY }
 
+/**
+ * Clock convention for time-of-day labels. AUTO follows the device's 24-hour
+ * system setting; the others force a 12- or 24-hour clock app-wide.
+ */
+enum class TimeFormatPref { AUTO, TWELVE_HOUR, TWENTY_FOUR_HOUR }
+
+/**
+ * Resolve to a concrete 24-hour flag. AUTO defers to [systemIs24Hour] (the
+ * device's `DateFormat.is24HourFormat` value).
+ */
+fun TimeFormatPref.is24Hour(systemIs24Hour: Boolean): Boolean = when (this) {
+    TimeFormatPref.AUTO -> systemIs24Hour
+    TimeFormatPref.TWELVE_HOUR -> false
+    TimeFormatPref.TWENTY_FOUR_HOUR -> true
+}
+
 /**
  * Resolve the preference to a concrete first-day-of-week. AUTO reads the
  * locale's convention (e.g. Monday in DE, Sunday in en-US).
@@ -70,6 +86,27 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[WEEK_START_KEY] = pref.name }
     }
 
+    /** Clock convention for time-of-day labels (v2.11). Defaults to AUTO (system). */
+    val timeFormat: Flow<TimeFormatPref> = store.data.map { prefs ->
+        prefs[TIME_FORMAT_KEY].toEnum(TimeFormatPref.AUTO)
+    }
+
+    suspend fun setTimeFormat(pref: TimeFormatPref) {
+        store.edit { it[TIME_FORMAT_KEY] = pref.name }
+    }
+
+    /**
+     * Whether the week/day timeline draws a faint separator line at each hour
+     * (v2.11). Defaults to OFF — the historical clean look; users opt in.
+     */
+    val showHourLines: Flow<Boolean> = store.data.map { prefs ->
+        prefs[SHOW_HOUR_LINES_KEY] ?: false
+    }
+
+    suspend fun setShowHourLines(enabled: Boolean) {
+        store.edit { it[SHOW_HOUR_LINES_KEY] = enabled }
+    }
+
     /**
      * The calendar view the app opens on (M1). Defaults to [CalendarView.Week] —
      * the historical hard-coded startup view — so existing users see no change
@@ -259,6 +296,8 @@ class SettingsPrefs @Inject constructor(
         internal val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
         internal val DYNAMIC_COLOR_KEY = booleanPreferencesKey("dynamic_color")
         internal val WEEK_START_KEY = stringPreferencesKey("week_start")
+        internal val TIME_FORMAT_KEY = stringPreferencesKey("time_format")
+        internal val SHOW_HOUR_LINES_KEY = booleanPreferencesKey("show_hour_lines")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/EventReminderReceiver.kt

@@ -46,7 +46,7 @@ class EventReminderReceiver : BroadcastReceiver() {
                 if (settingsPrefs.remindersEnabled.first()) {
                     val now = System.currentTimeMillis()
                     val due = alertStore.dueAlerts(now)
-                    due.forEach(notifier::post)
+                    due.forEach { notifier.post(it) }
                     alertStore.markFired(due.map { it.alertId }, now)
                 }
             } finally {

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt

@@ -14,6 +14,9 @@ import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
+import kotlinx.coroutines.flow.first
 import java.time.ZoneId
 import java.util.Locale
 import javax.inject.Inject
@@ -29,6 +32,7 @@ import javax.inject.Singleton
 @Singleton
 class ReminderNotifier @Inject constructor(
     @ApplicationContext private val context: Context,
+    private val settingsPrefs: SettingsPrefs,
 ) {
 
     /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */
@@ -39,15 +43,18 @@ class ReminderNotifier @Inject constructor(
         return granted && NotificationManagerCompat.from(context).areNotificationsEnabled()
     }
 
-    fun post(alert: ReminderAlert) {
+    suspend fun post(alert: ReminderAlert) {
         ensureChannel()
         val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
+        val is24Hour = settingsPrefs.timeFormat.first()
+            .is24Hour(android.text.format.DateFormat.is24HourFormat(context))
         val time = reminderTimeText(
             beginMillis = alert.beginMillis,
             endMillis = alert.endMillis,
             isAllDay = alert.isAllDay,
             zone = ZoneId.systemDefault(),
             locale = Locale.getDefault(),
+            is24Hour = is24Hour,
         )
         val text = listOfNotNull(time, alert.location).joinToString(" · ")
         val notification = NotificationCompat.Builder(context, CHANNEL_ID)

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.reminders
 
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -25,6 +26,7 @@ fun reminderTimeText(
     isAllDay: Boolean,
     zone: ZoneId,
     locale: Locale,
+    is24Hour: Boolean,
 ): String {
     if (isAllDay) {
         val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
@@ -40,16 +42,18 @@ fun reminderTimeText(
         }
     }
 
-    val timeFormat = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val timeFormat = timeOfDayFormatter(is24Hour, locale)
     val begin = Instant.ofEpochMilli(beginMillis).atZone(zone)
     val end = Instant.ofEpochMilli(endMillis).atZone(zone)
     return if (begin.toLocalDate() == end.toLocalDate()) {
         timeFormat.format(begin) + RANGE + timeFormat.format(end)
     } else {
-        val dateTimeFormat = DateTimeFormatter
-            .ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT)
-            .withLocale(locale)
-        dateTimeFormat.format(begin) + RANGE + dateTimeFormat.format(end)
+        // Cross-day: medium date + the chosen short time, joined per side. Built
+        // from the two formatters (not ofLocalizedDateTime) so the 12/24h choice
+        // applies to the time portion too.
+        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+        val dateTime = { z: java.time.ZonedDateTime -> "${dateFormat.format(z)}, ${timeFormat.format(z)}" }
+        dateTime(begin) + RANGE + dateTime(end)
     }
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt

@@ -58,6 +58,9 @@ import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.positionOf
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import kotlinx.coroutines.launch
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
@@ -338,15 +341,17 @@ private fun agendaTimeSummary(event: EventInstance): String {
     val time = if (event.isAllDay) {
         stringResource(R.string.event_detail_all_day)
     } else {
-        "${formatTime(event.start)} – ${formatTime(event.end)}"
+        val is24Hour = LocalUse24HourFormat.current
+        val locale = currentLocale()
+        "${formatTime(event.start, is24Hour, locale)} – ${formatTime(event.end, is24Hour, locale)}"
     }
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time
 }
 
-private fun formatTime(instant: Instant): String {
+private fun formatTime(instant: Instant, is24Hour: Boolean, locale: Locale): String {
     val t = instant.toLocalDateTime(zone).time
-    return "%02d:%02d".format(t.hour, t.minute)
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
 }
 
 private fun formatAgendaDate(date: LocalDate): String {

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt

@@ -30,7 +30,6 @@ import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
-import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.filled.FileDownload
 import androidx.compose.material.icons.filled.OpenInNew
 import androidx.compose.material.icons.filled.Palette
@@ -45,6 +44,7 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
@@ -58,11 +58,14 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
@@ -98,6 +101,7 @@ fun CalendarsScreen(
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
+    val disabledIds by viewModel.disabledCalendarIds.collectAsStateWithLifecycle()
     val error by viewModel.error.collectAsStateWithLifecycle()
     val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
 
@@ -134,6 +138,7 @@ fun CalendarsScreen(
         CalendarsList(
             local = calendars.filter { it.isLocal },
             synced = calendars.filterNot { it.isLocal },
+            disabledIds = disabledIds,
             error = error,
             onConsumeError = viewModel::consumeError,
             backupResult = backupResult,
@@ -142,6 +147,7 @@ fun CalendarsScreen(
             onBack = onBack,
             onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
             onEdit = { calendar -> editorSession++; editorId = calendar.id },
+            onSetDisabled = viewModel::setDisabled,
         )
     }
 }
@@ -150,6 +156,7 @@ fun CalendarsScreen(
 private fun CalendarsList(
     local: List<CalendarSource>,
     synced: List<CalendarSource>,
+    disabledIds: Set<Long>,
     error: Boolean,
     onConsumeError: () -> Unit,
     backupResult: BackupResult?,
@@ -158,6 +165,7 @@ private fun CalendarsList(
     onBack: () -> Unit,
     onAdd: () -> Unit,
     onEdit: (CalendarSource) -> Unit,
+    onSetDisabled: (Long, Boolean) -> Unit,
 ) {
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
@@ -206,19 +214,21 @@ private fun CalendarsList(
         if (local.isEmpty()) {
             HintText(stringResource(R.string.calendars_local_empty))
         }
+        HintText(stringResource(R.string.calendars_disable_hint))
         val localCount = local.size + 1
         local.forEachIndexed { index, calendar ->
+            val disabled = calendar.id in disabledIds
             GroupedRow(
                 title = calendar.displayName,
                 summary = calendar.description,
                 position = positionOf(index, localCount),
-                leading = { CalendarColorChip(calendar.color) },
+                dimmed = disabled,
+                leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
                 trailing = {
-                    Icon(
-                        Icons.Default.Edit,
-                        contentDescription = stringResource(R.string.calendars_edit_title),
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                        modifier = Modifier.size(20.dp),
+                    EnableSwitch(
+                        calendarName = calendar.displayName,
+                        enabled = !disabled,
+                        onToggle = { enabled -> onSetDisabled(calendar.id, !enabled) },
                     )
                 },
                 onClick = { onEdit(calendar) },
@@ -258,10 +268,19 @@ private fun CalendarsList(
             .forEach { (account, cals) ->
                 AccountHeader(account = account, accountType = cals.first().accountType)
                 cals.forEachIndexed { index, calendar ->
+                    val disabled = calendar.id in disabledIds
                     GroupedRow(
                         title = calendar.displayName,
                         position = positionOf(index, cals.size),
-                        leading = { CalendarColorChip(calendar.color) },
+                        dimmed = disabled,
+                        leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
+                        trailing = {
+                            EnableSwitch(
+                                calendarName = calendar.displayName,
+                                enabled = !disabled,
+                                onToggle = { enabled -> onSetDisabled(calendar.id, !enabled) },
+                            )
+                        },
                     )
                 }
             }
@@ -424,6 +443,30 @@ private fun CalendarEditor(
     }
 }
 
+/**
+ * The per-row enable/disable control. Checked = the calendar is shown in the
+ * app; unchecking disables it (events, filters and pickers all drop it) without
+ * touching any provider data. Carries its own content description so the toggle
+ * is self-describing to screen readers even on a dimmed row.
+ */
+@Composable
+private fun EnableSwitch(
+    calendarName: String,
+    enabled: Boolean,
+    onToggle: (Boolean) -> Unit,
+) {
+    val label = stringResource(R.string.calendars_show_in_app_a11y, calendarName)
+    Switch(
+        checked = enabled,
+        onCheckedChange = onToggle,
+        modifier = Modifier.semantics { contentDescription = label },
+    )
+}
+
+/** Fade a leading element to the M3 disabled emphasis when [disabled]. */
+private fun dimIf(disabled: Boolean): Modifier =
+    if (disabled) Modifier.alpha(0.38f) else Modifier
+
 /** Tonal field card matching the event editor's design (icon + content). */
 @Composable
 private fun EditorCard(

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -7,6 +7,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
@@ -15,6 +16,7 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
@@ -33,6 +35,7 @@ import javax.inject.Inject
 class CalendarsViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val icsExporter: IcsExporter,
+    private val prefs: CalendarPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -46,6 +49,20 @@ class CalendarsViewModel @Inject constructor(
                 initialValue = emptyList(),
             )
 
+    /**
+     * Calendars the user has disabled in the app. This screen is the only
+     * surface that lists them, so it both reads the set (to dim the rows) and
+     * toggles it. Every other surface simply excludes these ids.
+     */
+    val disabledCalendarIds: StateFlow<Set<Long>> =
+        prefs.disabledCalendarIds
+            .flowOn(io)
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
+                initialValue = emptySet(),
+            )
+
     private val _error = MutableStateFlow(false)
     val error: StateFlow<Boolean> = _error.asStateFlow()
 
@@ -93,6 +110,19 @@ class CalendarsViewModel @Inject constructor(
         repository.deleteCalendar(id)
     }
 
+    /**
+     * Enable or disable a calendar app-side. Disabling removes it from every
+     * surface but Settings → Calendars (and hides its events) without touching
+     * provider data — purely a reversible Calendula-local view choice.
+     */
+    fun setDisabled(id: Long, disabled: Boolean) {
+        viewModelScope.launch {
+            val current = prefs.disabledCalendarIds.first()
+            val next = if (disabled) current + id else current - id
+            if (next != current) prefs.setDisabledCalendarIds(next)
+        }
+    }
+
     private inline fun write(crossinline block: suspend () -> Unit) {
         viewModelScope.launch {
             try {

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/GroupedList.kt

@@ -127,7 +127,9 @@ fun CollapsingScaffold(
  * One row in a grouped list: an M3 [ListItem] over a tonal [Surface] whose
  * corner radii come from its [position] (so a run of rows reads as a single
  * rounded card). Corners round further on press. A null [onClick] makes the
- * row non-interactive (e.g. read-only entries).
+ * row non-interactive (e.g. read-only entries). [dimmed] fades the headline and
+ * summary to the M3 disabled emphasis while leaving the [trailing] control at
+ * full opacity — for rows that are present but switched off.
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -137,6 +139,7 @@ fun GroupedRow(
     modifier: Modifier = Modifier,
     summary: String? = null,
     selected: Boolean = false,
+    dimmed: Boolean = false,
     minHeight: Dp = 72.dp,
     leading: @Composable (() -> Unit)? = null,
     trailing: @Composable (() -> Unit)? = null,
@@ -168,6 +171,16 @@ fun GroupedRow(
             supportingColor = MaterialTheme.colorScheme.onSecondaryContainer,
             trailingIconColor = MaterialTheme.colorScheme.onSecondaryContainer,
         )
+    } else if (dimmed) {
+        // M3 disabled emphasis (0.38α) on the text/leading; the trailing control
+        // stays full-opacity so the toggle reads as live even on a faded row.
+        val muted = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f)
+        ListItemDefaults.colors(
+            containerColor = Color.Transparent,
+            headlineColor = muted,
+            leadingIconColor = muted,
+            supportingColor = muted,
+        )
     } else {
         ListItemDefaults.colors(containerColor = Color.Transparent)
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/HourLines.kt

@@ -0,0 +1,38 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Whether the week/day timeline draws an hour separator line, from the
+ * `showHourLines` preference. Provided once at the app root (like
+ * [LocalUse24HourFormat]) so the timeline reads it without ViewModel plumbing.
+ * Defaults to off — the historical clean look.
+ */
+val LocalShowHourLines = staticCompositionLocalOf { false }
+
+/**
+ * Draw a faint separator line at the top of each hour (1..23) when [show] is
+ * true. Applied to a day column's content so each line sits over the column's
+ * background but beneath the event blocks. [hourHeightPx] is one hour's pixel
+ * height; [color] is resolved by the caller from the theme.
+ */
+fun Modifier.hourSeparatorLines(show: Boolean, hourHeightPx: Float, color: Color): Modifier =
+    if (!show) {
+        this
+    } else {
+        drawBehind {
+            for (hour in 1 until 24) {
+                val y = hour * hourHeightPx
+                drawLine(
+                    color = color,
+                    start = Offset(0f, y),
+                    end = Offset(size.width, y),
+                    strokeWidth = 1f,
+                )
+            }
+        }
+    }

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimeFormat.kt

@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import java.time.LocalTime
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * The resolved clock convention for the whole UI: `true` = 24-hour ("14:00"),
+ * `false` = 12-hour ("2:00 PM"). Provided once at the app root from the
+ * `TimeFormatPref` preference resolved against the device's 24-hour system
+ * setting, so every time label reads it without per-screen plumbing. Defaults
+ * to 24-hour for previews and any composition that forgets to provide it.
+ */
+val LocalUse24HourFormat = staticCompositionLocalOf { true }
+
+private const val PATTERN_24 = "HH:mm"
+private const val PATTERN_12 = "h:mm a"
+private const val HOUR_PATTERN_12 = "h a"
+
+/** A time-of-day [DateTimeFormatter] for the resolved convention and [locale]. */
+fun timeOfDayFormatter(is24Hour: Boolean, locale: Locale): DateTimeFormatter =
+    DateTimeFormatter.ofPattern(if (is24Hour) PATTERN_24 else PATTERN_12, locale)
+
+/**
+ * Format a wall-clock time (hour 0..23, minute 0..59) honouring the resolved
+ * [is24Hour] convention and [locale]: 24h → "14:00", 12h → "2:00 PM". Pure, so
+ * it can be unit-tested and used off the main thread (widget, notifications).
+ */
+fun formatTimeOfDay(hour: Int, minute: Int, is24Hour: Boolean, locale: Locale): String =
+    LocalTime.of(hour.coerceIn(0, 23), minute.coerceIn(0, 59))
+        .format(timeOfDayFormatter(is24Hour, locale))
+
+/**
+ * Format minutes-from-midnight (0..1440) as a time label. The end-of-day value
+ * 1440 renders as "24:00" in 24h (its established reading) and as midnight
+ * ("12:00 AM") in 12h, which has no 24:00 equivalent.
+ */
+fun formatMinuteOfDay(minutes: Int, is24Hour: Boolean, locale: Locale): String = when {
+    minutes >= MINUTES_PER_DAY && is24Hour -> "24:00"
+    minutes >= MINUTES_PER_DAY -> formatTimeOfDay(0, 0, is24Hour = false, locale)
+    else -> formatTimeOfDay(minutes / 60, minutes % 60, is24Hour, locale)
+}
+
+/**
+ * The compact hour-only label for a timeline gutter: 24h → "13" (zero-padded,
+ * the prior look); 12h → "1 PM".
+ */
+fun formatHourLabel(hour: Int, is24Hour: Boolean, locale: Locale): String =
+    if (is24Hour) {
+        "%02d".format(hour)
+    } else {
+        LocalTime.of(hour.coerceIn(0, 23), 0)
+            .format(DateTimeFormatter.ofPattern(HOUR_PATTERN_12, locale))
+    }
+
+private const val MINUTES_PER_DAY = 1_440

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt

@@ -80,7 +80,12 @@ import de.jeanlucmakiola.calendula.ui.common.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
+import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -466,6 +471,8 @@ private fun Timeline(
 ) {
     val totalHeight = HOUR_HEIGHT * 24
     val dark = isSystemInDarkTheme()
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
 
     Box(modifier = Modifier.fillMaxSize()) {
         // Gutter and day column are two scroll viewports that SHARE one scroll
@@ -488,7 +495,7 @@ private fun Timeline(
                     ) {
                         if (h > 0) {
                             Text(
-                                text = "%02d".format(h),
+                                text = formatHourLabel(h, use24Hour, locale),
                                 style = MaterialTheme.typography.labelSmall,
                                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                                 modifier = Modifier
@@ -534,6 +541,8 @@ private fun DayColumnCard(
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
+    val showHourLines = LocalShowHourLines.current
+    val hourLineColor = MaterialTheme.colorScheme.outlineVariant
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -546,6 +555,9 @@ private fun DayColumnCard(
         BoxWithConstraints(
             modifier = Modifier
                 .fillMaxSize()
+                // Faint hour separators sit over the column background but under
+                // the event blocks (drawBehind paints before the children).
+                .hourSeparatorLines(showHourLines, hourPx, hourLineColor)
                 // Tap an empty slot to create an event there. Taps on event
                 // blocks are consumed by their own click handler first, so this
                 // only fires on the column background. Snaps to the tapped hour.
@@ -589,7 +601,10 @@ private fun EventBlock(
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
+        minToHm(block.endMin, use24Hour, locale)
     val showTime = block.endMin - block.startMin >= 45
     Box(
         modifier = modifier
@@ -635,8 +650,8 @@ private fun DayLoading() {
     }
 }
 
-private fun minToHm(min: Int): String =
-    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+private fun minToHm(min: Int, is24Hour: Boolean, locale: Locale): String =
+    formatMinuteOfDay(min, is24Hour, locale)
 
 private fun formatDayTitle(date: LocalDate): String {
     val locale = Locale.getDefault()

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -95,6 +95,8 @@ import de.jeanlucmakiola.calendula.ui.common.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.OptionCard
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
@@ -781,7 +783,7 @@ private fun formatWhen(
     val zid = ZoneId.of(zone.id)
     val dateFull = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(locale)
     val dateMedium = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
-    val timeShort = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val timeShort = timeOfDayFormatter(LocalUse24HourFormat.current, locale)
 
     val startLdt = instance.start.toJavaLocalDateTime(zid)
     val allDayLabel = stringResource(R.string.event_detail_all_day)

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt

@@ -132,6 +132,8 @@ import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
 import de.jeanlucmakiola.calendula.ui.common.ReminderUnit
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.reminderUnitLabel
 import de.jeanlucmakiola.calendula.ui.common.pastelize
@@ -1891,8 +1893,9 @@ private fun ScheduleRow(
     val dateFormat = remember(locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
     }
-    val timeFormat = remember(locale) {
-        DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val use24Hour = LocalUse24HourFormat.current
+    val timeFormat = remember(locale, use24Hour) {
+        timeOfDayFormatter(use24Hour, locale)
     }
     // Tappable values read as links (primary), like the location on the
     // detail screen; errors flip them to the error colour.

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt

@@ -121,10 +121,18 @@ class EventEditViewModel @Inject constructor(
         val allowColorOnUnsupported: Boolean,
     )
 
-    /** Writable calendars — the only valid event targets. */
-    private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
-        .map { calendars -> calendars.filter { it.canModifyContents } }
-        .catch { emit(emptyList()) }
+    /**
+     * Writable calendars — the only valid event targets. Disabled calendars are
+     * excluded, so you can't create into a calendar you've removed from the app;
+     * a last-used preselect landing on a now-disabled calendar falls back to the
+     * first remaining writable one (handled by [resolvedCalendarId] and [state]).
+     */
+    private val writableCalendars: Flow<List<CalendarSource>> = combine(
+        repository.calendars(),
+        prefs.disabledCalendarIds,
+    ) { calendars, disabled ->
+        calendars.filter { it.canModifyContents && it.id !in disabled }
+    }.catch { emit(emptyList()) }
 
     /** The target calendar id, resolved exactly as the form shows it. */
     private val resolvedCalendarId: Flow<Long?> = combine(

app/src/main/java/de/jeanlucmakiola/calendula/ui/filter/FilterViewModel.kt

@@ -30,11 +30,16 @@ class FilterViewModel @Inject constructor(
         combine(
             repository.calendars(),
             prefs.hiddenCalendarIds,
-        ) { calendars, hidden ->
-            if (calendars.isEmpty()) {
+            prefs.disabledCalendarIds,
+        ) { calendars, hidden, disabled ->
+            // Disabled calendars are gone from the app entirely — they don't
+            // belong in the drawer's hide/show list (you can't hide what's
+            // already disabled). They live only in Settings → Calendars.
+            val enabled = calendars.filterNot { it.id in disabled }
+            if (enabled.isEmpty()) {
                 FilterUiState.Failure(FailureReason.NoCalendarsConfigured)
             } else {
-                FilterUiState.Success(groupByAccount(calendars, hidden))
+                FilterUiState.Success(groupByAccount(enabled, hidden))
             }
         }
             .catch { emit(FilterUiState.Failure(FailureReason.ProviderUnavailable)) }

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportViewModel.kt

@@ -7,6 +7,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsImporter
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
@@ -56,6 +57,7 @@ sealed interface ImportUiState {
 class ImportViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val importer: IcsImporter,
+    private val prefs: CalendarPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -79,11 +81,17 @@ class ImportViewModel @Inject constructor(
                     form = parsed.events.single().toEventForm(TimeZone.currentSystemDefault()),
                     warnings = parsed.warnings,
                 )
-                else -> ImportUiState.Many(
-                    events = parsed.events,
-                    warnings = parsed.warnings,
-                    calendars = repository.calendars().first().filter { it.canModifyContents },
-                )
+                else -> {
+                    // A disabled calendar is removed from the app, so it can't be
+                    // an import target — exclude it alongside the read-only ones.
+                    val disabled = prefs.disabledCalendarIds.first()
+                    ImportUiState.Many(
+                        events = parsed.events,
+                        warnings = parsed.warnings,
+                        calendars = repository.calendars().first()
+                            .filter { it.canModifyContents && it.id !in disabled },
+                    )
+                }
             }
         }
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt

@@ -54,6 +54,8 @@ import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.InlineTextField
 import de.jeanlucmakiola.calendula.ui.common.Position
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.positionOf
 import java.time.Instant as JavaInstant
@@ -217,12 +219,11 @@ private fun searchSummary(event: EventInstance): String {
     val dateText = remember(locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
     }.format(start)
+    val use24Hour = LocalUse24HourFormat.current
     val timeText = if (event.isAllDay) {
         stringResource(R.string.event_detail_all_day)
     } else {
-        remember(locale) {
-            DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
-        }.format(start)
+        remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
     }
     val base = "$dateText · $timeText"
     return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt

@@ -42,11 +42,13 @@ import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.ExpandLess
 import androidx.compose.material.icons.filled.ExpandMore
+import androidx.compose.material.icons.filled.Favorite
 import androidx.compose.material.icons.filled.Gavel
 import androidx.compose.material.icons.filled.Language
 import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.Tune
+import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
@@ -82,6 +84,7 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.qs.NewEventTileService
@@ -292,6 +295,7 @@ private fun AboutCard() {
     val context = LocalContext.current
     val sourceUrl = stringResource(R.string.about_source_url)
     val licenseUrl = stringResource(R.string.about_license_url)
+    val supportUrl = stringResource(R.string.about_support_url)
 
     Surface(
         color = MaterialTheme.colorScheme.surfaceContainerHigh,
@@ -350,6 +354,19 @@ private fun AboutCard() {
                     Text(stringResource(R.string.settings_license))
                 }
             }
+            Spacer(Modifier.height(8.dp))
+            FilledTonalButton(
+                onClick = { openUrl(context, supportUrl) },
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                Icon(
+                    Icons.Default.Favorite,
+                    contentDescription = null,
+                    modifier = Modifier.size(18.dp),
+                )
+                Spacer(Modifier.width(8.dp))
+                Text(stringResource(R.string.settings_about_support))
+            }
         }
     }
 }
@@ -408,6 +425,7 @@ private fun AppearanceScreen(
 ) {
     var showTheme by remember { mutableStateOf(false) }
     var showWeekStart by remember { mutableStateOf(false) }
+    var showTimeFormat by remember { mutableStateOf(false) }
     var showDefaultView by remember { mutableStateOf(false) }
 
     CollapsingScaffold(
@@ -450,9 +468,27 @@ private fun AppearanceScreen(
         GroupedRow(
             title = stringResource(R.string.settings_week_start),
             summary = weekStartLabel(state.weekStart),
-            position = Position.Bottom,
+            position = Position.Middle,
             onClick = { showWeekStart = true },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_time_format),
+            summary = timeFormatLabel(state.timeFormat),
+            position = Position.Middle,
+            onClick = { showTimeFormat = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_hour_lines),
+            summary = stringResource(R.string.settings_hour_lines_summary),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.showHourLines,
+                    onCheckedChange = viewModel::setShowHourLines,
+                )
+            },
+            onClick = { viewModel.setShowHourLines(!state.showHourLines) },
+        )
     }
 
     if (showTheme) {
@@ -475,6 +511,16 @@ private fun AppearanceScreen(
             onDismiss = { showWeekStart = false },
         )
     }
+    if (showTimeFormat) {
+        OptionPicker(
+            title = stringResource(R.string.settings_time_format),
+            options = TimeFormatPref.entries,
+            selected = state.timeFormat,
+            label = { timeFormatLabel(it) },
+            onSelect = viewModel::setTimeFormat,
+            onDismiss = { showTimeFormat = false },
+        )
+    }
     if (showDefaultView) {
         OptionPicker(
             title = stringResource(R.string.settings_default_view),
@@ -986,6 +1032,15 @@ private fun weekStartLabel(pref: WeekStartPref): String = stringResource(
     },
 )
 
+@Composable
+private fun timeFormatLabel(pref: TimeFormatPref): String = stringResource(
+    when (pref) {
+        TimeFormatPref.AUTO -> R.string.settings_time_format_auto
+        TimeFormatPref.TWELVE_HOUR -> R.string.settings_time_format_12h
+        TimeFormatPref.TWENTY_FOUR_HOUR -> R.string.settings_time_format_24h
+    },
+)
+
 @Composable
 private fun languageLabel(tag: String?): String =
     if (tag == null) stringResource(R.string.settings_language_auto) else AppLanguage.displayName(tag)

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.ui.settings
 
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
@@ -18,6 +19,10 @@ data class SettingsUiState(
     val dynamicColor: Boolean = true,
     val dynamicColorAvailable: Boolean = true,
     val weekStart: WeekStartPref = WeekStartPref.AUTO,
+    /** Clock convention for time labels (v2.11). AUTO follows the system setting. */
+    val timeFormat: TimeFormatPref = TimeFormatPref.AUTO,
+    /** Whether the week/day timeline draws an hour separator line (v2.11). */
+    val showHourLines: Boolean = false,
     /** The calendar view the app opens on, and the home of the view back stack (M1). */
     val defaultView: CalendarView = CalendarView.Week,
     /** Optional event-form fields shown by default (rest behind "more fields"). */

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt

@@ -8,6 +8,7 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
@@ -73,10 +74,13 @@ class SettingsViewModel @Inject constructor(
             ) { overrides, allDayOverrides, calendars ->
                 ReminderOverrides(overrides, allDayOverrides, calendars)
             },
-            prefs.defaultView,
-        ) { base, defaults, overrides, defaultView ->
+            combine(prefs.defaultView, prefs.timeFormat) { view, timeFormat -> view to timeFormat },
+            prefs.showHourLines,
+        ) { base, defaults, overrides, viewAndTimeFormat, showHourLines ->
             base.copy(
-                defaultView = defaultView,
+                defaultView = viewAndTimeFormat.first,
+                timeFormat = viewAndTimeFormat.second,
+                showHourLines = showHourLines,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -118,6 +122,14 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setWeekStart(pref) }
     }
 
+    fun setTimeFormat(pref: TimeFormatPref) {
+        viewModelScope.launch { prefs.setTimeFormat(pref) }
+    }
+
+    fun setShowHourLines(enabled: Boolean) {
+        viewModelScope.launch { prefs.setShowHourLines(enabled) }
+    }
+
     fun setDefaultView(view: CalendarView) {
         viewModelScope.launch { prefs.setDefaultView(view) }
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt

@@ -83,6 +83,11 @@ import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.common.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
+import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
@@ -572,6 +577,8 @@ private fun Timeline(
 ) {
     val totalHeight = HOUR_HEIGHT * 24
     val dark = isSystemInDarkTheme()
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
 
     Box(modifier = Modifier.fillMaxSize()) {
         // Gutter and day columns are two scroll viewports that SHARE one scroll
@@ -595,7 +602,7 @@ private fun Timeline(
                     ) {
                         if (h > 0) {
                             Text(
-                                text = "%02d".format(h),
+                                text = formatHourLabel(h, use24Hour, locale),
                                 style = MaterialTheme.typography.labelSmall,
                                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                                 modifier = Modifier
@@ -650,6 +657,8 @@ private fun DayColumnCard(
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
+    val showHourLines = LocalShowHourLines.current
+    val hourLineColor = MaterialTheme.colorScheme.outlineVariant
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -662,6 +671,9 @@ private fun DayColumnCard(
         BoxWithConstraints(
             modifier = Modifier
                 .fillMaxSize()
+                // Faint hour separators sit over the column background but under
+                // the event blocks (drawBehind paints before the children).
+                .hourSeparatorLines(showHourLines, hourPx, hourLineColor)
                 // Tap an empty slot to create an event there; taps on event
                 // blocks are consumed by their own handler first. Snaps to hour.
                 .pointerInput(date) {
@@ -704,7 +716,10 @@ private fun EventBlock(
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
+        minToHm(block.endMin, use24Hour, locale)
     val showTime = block.endMin - block.startMin >= 45
     Box(
         modifier = modifier
@@ -773,8 +788,8 @@ private fun WeekLoading() {
     }
 }
 
-private fun minToHm(min: Int): String =
-    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): String =
+    formatMinuteOfDay(min, is24Hour, locale)
 
 private fun formatWeekRange(weekStart: LocalDate): String {
     val locale = Locale.getDefault()

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt

@@ -4,6 +4,7 @@ import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import androidx.core.content.ContextCompat
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaDay
@@ -46,7 +47,12 @@ internal fun Context.hasCalendarPermission(): Boolean =
 sealed interface AgendaWidgetData {
     /** Calendar permission not granted — the widget can't read events. */
     data object NeedsPermission : AgendaWidgetData
-    data class Ready(val today: LocalDate, val days: List<AgendaDay>) : AgendaWidgetData
+    data class Ready(
+        val today: LocalDate,
+        val days: List<AgendaDay>,
+        /** Resolved clock convention for event time labels (the time-format pref). */
+        val is24Hour: Boolean,
+    ) : AgendaWidgetData
 }
 
 /**
@@ -91,9 +97,15 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
     if (!hasCalendarPermission()) return AgendaWidgetData.NeedsPermission
     val zone = systemZone()
     val anchor = today(zone)
-    val repo = widgetEntryPoint().calendarRepository()
-    val instances = repo.instances(agendaRange(anchor, AGENDA_WIDGET_DAYS, zone)).first()
-    return AgendaWidgetData.Ready(today = anchor, days = groupAgendaDays(anchor, instances, zone))
+    val ep = widgetEntryPoint()
+    val instances = ep.calendarRepository().instances(agendaRange(anchor, AGENDA_WIDGET_DAYS, zone)).first()
+    val is24Hour = ep.settingsPrefs().timeFormat.first()
+        .is24Hour(android.text.format.DateFormat.is24HourFormat(this))
+    return AgendaWidgetData.Ready(
+        today = anchor,
+        days = groupAgendaDays(anchor, instances, zone),
+        is24Hour = is24Hour,
+    )
 }
 
 /** One-shot wide read backing the month widget's grid for any nearby month. */

app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt

@@ -42,6 +42,7 @@ import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme
@@ -115,7 +116,7 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                         items(rows.size) { index ->
                             when (val row = rows[index]) {
                                 is AgendaRow.Header -> DayHeaderRow(row.date, row.today)
-                                is AgendaRow.Event -> EventRow(row.event, dark)
+                                is AgendaRow.Event -> EventRow(row.event, dark, data.is24Hour)
                             }
                         }
                     }
@@ -195,7 +196,7 @@ private fun DayHeaderRow(date: LocalDate, today: LocalDate) {
 }
 
 @Composable
-private fun EventRow(event: EventInstance, dark: Boolean) {
+private fun EventRow(event: EventInstance, dark: Boolean, is24Hour: Boolean) {
     val context = androidx.glance.LocalContext.current
     val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
     Row(
@@ -230,7 +231,7 @@ private fun EventRow(event: EventInstance, dark: Boolean) {
                 style = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 14.sp),
             )
             Text(
-                text = eventTimeSummary(context, event),
+                text = eventTimeSummary(context, event, is24Hour),
                 maxLines = 1,
                 style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 12.sp),
             )
@@ -269,17 +270,17 @@ private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate):
     return if (relative != null) "$relative · $formatted" else formatted
 }
 
-private fun eventTimeSummary(context: Context, event: EventInstance): String {
+private fun eventTimeSummary(context: Context, event: EventInstance, is24Hour: Boolean): String {
     val time = if (event.isAllDay) {
         context.getString(R.string.event_detail_all_day)
     } else {
-        "${formatTime(event.start)} – ${formatTime(event.end)}"
+        "${formatTime(event.start, is24Hour)} – ${formatTime(event.end, is24Hour)}"
     }
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time
 }
 
-private fun formatTime(instant: Instant): String {
+private fun formatTime(instant: Instant, is24Hour: Boolean): String {
     val t = instant.toLocalDateTime(zone()).time
-    return "%02d:%02d".format(t.hour, t.minute)
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, Locale.getDefault())
 }

app/src/main/res/values-de/strings.xml

@@ -278,6 +278,12 @@
     <string name="settings_week_start_auto">Automatisch</string>
     <string name="settings_week_start_monday">Montag</string>
     <string name="settings_week_start_sunday">Sonntag</string>
+    <string name="settings_time_format">Zeitformat</string>
+    <string name="settings_time_format_auto">Automatisch</string>
+    <string name="settings_time_format_12h">12-Stunden (2:00 PM)</string>
+    <string name="settings_time_format_24h">24-Stunden (14:00)</string>
+    <string name="settings_hour_lines">Stundenlinien</string>
+    <string name="settings_hour_lines_summary">Trennlinie zu jeder vollen Stunde in Wochen- und Tagesansicht anzeigen</string>
     <string name="settings_section_event_form">Termin-Formular</string>
     <string name="settings_form_fields_hint">Standardmäßig angezeigte Felder — alles Weitere liegt hinter \"Weitere Felder\"</string>
     <string name="settings_color_unsupported">Farben auf nicht unterstützten Kalendern erlauben</string>
@@ -315,6 +321,7 @@
     <string name="settings_license_value">MIT</string>
     <string name="settings_about_author">von Jean-Luc Makiola</string>
     <string name="settings_about_source">Quellcode</string>
+    <string name="settings_about_support">Entwicklung unterstützen</string>
     <string name="settings_about_version">Version %1$s</string>
     <string name="settings_about_logo_desc">Calendula-App-Symbol</string>
     <string name="settings_report_problem">Problem melden</string>

app/src/main/res/values/strings.xml

@@ -271,6 +271,12 @@
     <string name="settings_week_start_auto">Automatic</string>
     <string name="settings_week_start_monday">Monday</string>
     <string name="settings_week_start_sunday">Sunday</string>
+    <string name="settings_time_format">Time format</string>
+    <string name="settings_time_format_auto">Automatic</string>
+    <string name="settings_time_format_12h">12-hour (2:00 PM)</string>
+    <string name="settings_time_format_24h">24-hour (14:00)</string>
+    <string name="settings_hour_lines">Hour lines</string>
+    <string name="settings_hour_lines_summary">Show a separator line at each hour in week and day view</string>
     <string name="settings_section_event_form">New event form</string>
     <string name="settings_form_fields_hint">Fields shown by default — everything else sits behind \"More fields\"</string>
     <string name="settings_color_unsupported">Allow colors on unsupported calendars</string>
@@ -308,6 +314,7 @@
     <string name="settings_license_value">MIT</string>
     <string name="settings_about_author">by Jean-Luc Makiola</string>
     <string name="settings_about_source">Source</string>
+    <string name="settings_about_support">Support development</string>
     <string name="settings_about_version">Version %1$s</string>
     <string name="settings_about_logo_desc">Calendula app icon</string>
     <string name="settings_report_problem">Report a problem</string>
@@ -318,6 +325,8 @@
     <string name="calendars_local_header">Your calendars</string>
     <string name="calendars_local_empty">No local calendars yet. Create one to keep events on this device only.</string>
     <string name="calendars_add">Add calendar</string>
+    <string name="calendars_disable_hint">Turn a calendar off to remove it from the app — its events, filters and pickers. Nothing is deleted, and you can turn it back on here anytime.</string>
+    <string name="calendars_show_in_app_a11y">Show \"%1$s\" in the app</string>
     <string name="calendars_synced_header">Synced calendars</string>
     <string name="calendars_synced_hint">These come from accounts on your device. Create and edit them in their own app.</string>
     <string name="calendars_manage_in_app">Manage</string>
@@ -378,6 +387,7 @@
 
     <string name="about_source_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula</string>
     <string name="about_license_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula/src/branch/main/LICENSE</string>
+    <string name="about_support_url" translatable="false">https://ko-fi.com/jeanlucmakiola</string>
 
     <!-- Crash reporting: a captured report the user can submit, by hand, as a
          Gitea issue (the app sends nothing automatically). -->

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt

@@ -170,6 +170,74 @@ class CalendarRepositoryImplTest {
         }
     }
 
+    @Test
+    fun `instances drops events whose calendar the user disabled`(@TempDir tempDir: Path) = runTest {
+        val prefs = newPrefs(tempDir)
+        prefs.setDisabledCalendarIds(setOf(2L))
+        val fake = FakeCalendarDataSource().apply {
+            instancesResult = { _, _ ->
+                listOf(
+                    makeEvent(10L, "Enabled", calendarId = 1L),
+                    makeEvent(11L, "Disabled", calendarId = 2L),
+                )
+            }
+        }
+        val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
+
+        val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
+        repo.instances(range).test {
+            assertThat(awaitItem().map { it.title }).containsExactly("Enabled")
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `instances applies the union of hidden and disabled sets`(@TempDir tempDir: Path) = runTest {
+        val prefs = newPrefs(tempDir)
+        prefs.setHiddenCalendarIds(setOf(2L))
+        prefs.setDisabledCalendarIds(setOf(3L))
+        val fake = FakeCalendarDataSource().apply {
+            instancesResult = { _, _ ->
+                listOf(
+                    makeEvent(10L, "Shown", calendarId = 1L),
+                    makeEvent(11L, "Hidden", calendarId = 2L),
+                    makeEvent(12L, "Disabled", calendarId = 3L),
+                )
+            }
+        }
+        val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
+
+        val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
+        repo.instances(range).test {
+            assertThat(awaitItem().map { it.title }).containsExactly("Shown")
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `instances re-emits when the disabled set changes`(@TempDir tempDir: Path) = runTest {
+        val prefs = newPrefs(tempDir)
+        val fake = FakeCalendarDataSource().apply {
+            instancesResult = { _, _ ->
+                listOf(
+                    makeEvent(10L, "A", calendarId = 1L),
+                    makeEvent(11L, "B", calendarId = 2L),
+                )
+            }
+        }
+        val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
+
+        val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
+        repo.instances(range).test {
+            assertThat(awaitItem().map { it.title }).containsExactly("A", "B").inOrder()
+
+            prefs.setDisabledCalendarIds(setOf(2L))
+
+            assertThat(awaitItem().map { it.title }).containsExactly("A")
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
     @Test
     fun `createEvent delegates and returns the new id`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource().apply { nextInsertId = 77L }

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefsTest.kt

@@ -50,4 +50,34 @@ class CalendarPrefsTest {
         }
         assertThat(prefs.hiddenCalendarIds.first()).isEqualTo(setOf(1L, 3L))
     }
+
+    @Test
+    fun `disabledCalendarIds defaults to empty when unset`(@TempDir tempDir: Path) = runTest {
+        val prefs = CalendarPrefs(newDataStore(tempDir))
+        assertThat(prefs.disabledCalendarIds.first()).isEmpty()
+    }
+
+    @Test
+    fun `setDisabledCalendarIds round-trips through DataStore`(@TempDir tempDir: Path) = runTest {
+        val prefs = CalendarPrefs(newDataStore(tempDir))
+        prefs.setDisabledCalendarIds(setOf(1L, 42L, 7L))
+        assertThat(prefs.disabledCalendarIds.first()).isEqualTo(setOf(1L, 42L, 7L))
+    }
+
+    @Test
+    fun `setting empty disabled set clears storage`(@TempDir tempDir: Path) = runTest {
+        val prefs = CalendarPrefs(newDataStore(tempDir))
+        prefs.setDisabledCalendarIds(setOf(1L))
+        prefs.setDisabledCalendarIds(emptySet())
+        assertThat(prefs.disabledCalendarIds.first()).isEmpty()
+    }
+
+    @Test
+    fun `hidden and disabled sets are stored independently`(@TempDir tempDir: Path) = runTest {
+        val prefs = CalendarPrefs(newDataStore(tempDir))
+        prefs.setHiddenCalendarIds(setOf(1L))
+        prefs.setDisabledCalendarIds(setOf(2L))
+        assertThat(prefs.hiddenCalendarIds.first()).isEqualTo(setOf(1L))
+        assertThat(prefs.disabledCalendarIds.first()).isEqualTo(setOf(2L))
+    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt

@@ -49,6 +49,22 @@ class SettingsPrefsTest {
         assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.SUNDAY)
     }
 
+    @Test
+    fun `time format defaults to auto and round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.timeFormat.first()).isEqualTo(TimeFormatPref.AUTO)
+        prefs.setTimeFormat(TimeFormatPref.TWELVE_HOUR)
+        assertThat(prefs.timeFormat.first()).isEqualTo(TimeFormatPref.TWELVE_HOUR)
+    }
+
+    @Test
+    fun `hour lines default off and round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.showHourLines.first()).isFalse()
+        prefs.setShowHourLines(true)
+        assertThat(prefs.showHourLines.first()).isTrue()
+    }
+
     @Test
     fun `garbage stored enum falls back to default`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)

app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt

@@ -26,10 +26,24 @@ class ReminderTimeTextTest {
             isAllDay = false,
             zone = berlin,
             locale = Locale.GERMANY,
+            is24Hour = true,
         )
         assertThat(text).isEqualTo("09:30 – 10:00")
     }
 
+    @Test
+    fun `12-hour preference renders an am-pm time range`() {
+        val text = reminderTimeText(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 14, 0), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 11, 15, 0), berlin),
+            isAllDay = false,
+            zone = berlin,
+            locale = Locale.US,
+            is24Hour = false,
+        )
+        assertThat(text).isEqualTo("2:00 PM – 3:00 PM")
+    }
+
     @Test
     fun `timed event crossing midnight includes both dates`() {
         val text = reminderTimeText(
@@ -38,6 +52,7 @@ class ReminderTimeTextTest {
             isAllDay = false,
             zone = berlin,
             locale = Locale.GERMANY,
+            is24Hour = true,
         )
         assertThat(text).contains("11.06.2026")
         assertThat(text).contains("12.06.2026")
@@ -54,6 +69,7 @@ class ReminderTimeTextTest {
             // 02:00 in Berlin — naive local reading would shift the day.
             zone = berlin,
             locale = Locale.GERMANY,
+            is24Hour = true,
         )
         assertThat(text).isEqualTo("11.06.2026")
     }
@@ -66,6 +82,7 @@ class ReminderTimeTextTest {
             isAllDay = true,
             zone = berlin,
             locale = Locale.GERMANY,
+            is24Hour = true,
         )
         assertThat(text).isEqualTo("11.06.2026 – 12.06.2026")
     }
@@ -79,6 +96,7 @@ class ReminderTimeTextTest {
             isAllDay = true,
             zone = berlin,
             locale = Locale.GERMANY,
+            is24Hour = true,
         )
         assertThat(text).isEqualTo("11.06.2026")
     }

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimeFormatTest.kt

@@ -0,0 +1,37 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Locale
+
+class TimeFormatTest {
+
+    @Test
+    fun `24-hour format is zero-padded HH mm`() {
+        assertThat(formatTimeOfDay(9, 5, is24Hour = true, Locale.US)).isEqualTo("09:05")
+        assertThat(formatTimeOfDay(14, 0, is24Hour = true, Locale.US)).isEqualTo("14:00")
+        assertThat(formatTimeOfDay(0, 0, is24Hour = true, Locale.US)).isEqualTo("00:00")
+    }
+
+    @Test
+    fun `12-hour format adds a localised am-pm marker`() {
+        assertThat(formatTimeOfDay(14, 0, is24Hour = false, Locale.US)).isEqualTo("2:00 PM")
+        assertThat(formatTimeOfDay(0, 30, is24Hour = false, Locale.US)).isEqualTo("12:30 AM")
+        assertThat(formatTimeOfDay(12, 0, is24Hour = false, Locale.US)).isEqualTo("12:00 PM")
+    }
+
+    @Test
+    fun `minute-of-day end-of-day renders 24 00 in 24h and midnight in 12h`() {
+        assertThat(formatMinuteOfDay(1_440, is24Hour = true, Locale.US)).isEqualTo("24:00")
+        assertThat(formatMinuteOfDay(1_440, is24Hour = false, Locale.US)).isEqualTo("12:00 AM")
+        assertThat(formatMinuteOfDay(13 * 60 + 15, is24Hour = true, Locale.US)).isEqualTo("13:15")
+    }
+
+    @Test
+    fun `hour label is zero-padded in 24h and compact am-pm in 12h`() {
+        assertThat(formatHourLabel(13, is24Hour = true, Locale.US)).isEqualTo("13")
+        assertThat(formatHourLabel(13, is24Hour = false, Locale.US)).isEqualTo("1 PM")
+        assertThat(formatHourLabel(1, is24Hour = false, Locale.US)).isEqualTo("1 AM")
+        assertThat(formatHourLabel(0, is24Hour = false, Locale.US)).isEqualTo("12 AM")
+    }
+}

docs/BUILDING.md

@@ -0,0 +1,24 @@
+# Building from source
+
+Calendula builds with the standard Android Gradle toolchain — no extra setup
+beyond the SDK and a JDK.
+
+## Requirements
+
+- **Android SDK 36+**
+- **JDK 17** — if your default JDK is not 17, set `JAVA_HOME` explicitly.
+
+The Gradle wrapper is checked in, so you don't need a system Gradle.
+
+## Common tasks
+
+```bash
+./gradlew assembleDebug   # debug APK → app/build/outputs/apk/debug/
+./gradlew test            # JVM unit tests
+./gradlew lint            # Android lint
+```
+
+## Release builds
+
+Release signing and the publishing pipeline are documented separately in
+[RELEASING.md](RELEASING.md).

docs/fdroid-official/de.jeanlucmakiola.calendula.yml

@@ -21,6 +21,7 @@ AuthorName: Jean-Luc Makiola
 SourceCode: https://gitea.jeanlucmakiola.de/makiolaj/calendula
 IssueTracker: https://gitea.jeanlucmakiola.de/makiolaj/calendula/issues
 Changelog: https://gitea.jeanlucmakiola.de/makiolaj/calendula/src/branch/main/CHANGELOG.md
+Donate: https://ko-fi.com/jeanlucmakiola
 
 AutoName: Calendula
 

fastlane/metadata/android/en-US/changelogs/21000.txt

@@ -0,0 +1,14 @@
+### Added
+- Turn a calendar off across the whole app. Settings → Calendars now has a
+  switch on every calendar — both your own and synced ones. Switching one off
+  removes it everywhere: its events disappear from all views and search, and it
+  drops out of the drawer's hide/show filter, the event-form calendar picker and
+  the import target picker. Unlike hiding (the quick per-view checkbox in the
+  drawer), a disabled calendar leaves the app entirely until you turn it back on.
+  Nothing is deleted and no other app is affected — it's a Calendula-only view
+  choice — so you can re-enable it any time from the same screen, where disabled
+  calendars stay listed but dimmed.
+- An optional way to support development. Settings → About now has a "Support
+  development" button that opens Ko-fi in your browser. It's a plain donation
+  link with no perks attached, and it needs no new permissions — Calendula still
+  has no internet access of its own and just hands the link to your browser.

fdroid-metadata/de.jeanlucmakiola.calendula.yml

@@ -8,3 +8,4 @@ Categories:
 
 SourceCode: https://gitea.jeanlucmakiola.de/makiolaj/calendula
 IssueTracker: https://gitea.jeanlucmakiola.de/makiolaj/calendula/issues
+Donate: https://ko-fi.com/jeanlucmakiola