Relive

Relive is your private, local-first timeline for preserving life’s moments in a beautiful personal archive.

Comment

Inspiration

Our lives are scattered across camera rolls, notes, voice recordings, and cloud folders. These tools preserve files, but they often lose the story surrounding them.

I built Relive because I wanted a private place where small moments could remain connected to their words, time, place, feelings, and meaning—without becoming social posts or disappearing into an endless gallery.

Relive is designed around a simple idea:

Capture now. Let time organize it. Rediscover it later.

What it does

Relive is a private, local-first personal memory timeline for Android and iOS.

A Moment can combine writing, photos, video, audio, a place, tags, and a feeling in one entry.

Instead of showing memories as a database-like list, Relive presents them through a warm, editorial timeline designed to feel like a personal life archive.

Every Moment automatically belongs to the main archive and can also appear in multiple custom timelines such as College, Family, or Japan 2026, without duplicating its underlying data.

Relive also helps people rediscover what they have saved through:

  • On This Day memories from previous years
  • From Your Past collections
  • Favourites
  • A dedicated media collection
  • Local search across writing, tags, and saved places
  • Calendar-based navigation
  • Mood insights calculated privately on the device
  • Printable Keepsake PDF exports
  • Portable .relive archive exports
  • Optional Google Drive backup and restore
  • Custom palettes, wallpapers, and timeline themes

There are no followers, public profiles, advertisements, or engagement algorithms.

Memories stay inside private app storage unless the user explicitly chooses to back them up or export them.

How I built it

Relive is built using Kotlin Multiplatform and Compose Multiplatform, allowing the app to share its domain logic, persistence, presentation layer, and much of its interface across Android and iOS.

The architecture follows clear boundaries:

Android + iOS hosts
        ↓
Shared Compose UI and presentation
        ↓
Domain models and policies
        ↑
Repositories and shared data layer
        ↓
SQLDelight + app-owned media storage

The archive uses SQLDelight over SQLite, with verified migrations and relational integrity.

Media is copied into app-owned storage so Moments never depend on temporary or fragile external file references.

Platform-specific capabilities such as:

  • Camera capture
  • Location
  • Media playback
  • Secure storage
  • File exports

are placed behind shared interfaces.

This keeps the core product independent of Android and iOS APIs while still allowing each platform to use its native capabilities.

For subscriptions, Relive integrates RevenueCat Purchases KMP.

RevenueCat acts as the source of truth for the relive_pro entitlement, including:

  • Monthly subscription
  • Annual subscription
  • Lifetime purchase

The demo build uses the RevenueCat Test Store, allowing the real purchase and restore lifecycle to be demonstrated without introducing a fake local unlock mechanism.

Optional Android backups use the narrow Google Drive appdata scope.

Portable archives contain versioned metadata, media, relationships, byte counts, and SHA-256 integrity hashes.

On Android, the live database is protected using SQLCipher, with a locally generated encryption key wrapped by Android Keystore.

Challenges I faced

Making memories feel worth revisiting

One of the hardest challenges was making the timeline feel like a personal life archive rather than another notes app.

That required careful work on:

  • Typography
  • Spacing
  • Media presentation
  • Motion
  • Themes
  • Timeline behavior
  • The continuous timeline rail

Visual polish was not separate from the product. It was essential to making old memories feel meaningful when encountered again.

Handling years of data efficiently

A personal archive may eventually contain years of Moments and media.

Loading everything when the app launches would not scale well.

To solve this, I designed bounded SQL-backed projections and paged feeds so each screen loads only the data it actually needs.

Cross-platform media

Photos, videos, audio recording, camera capture, storage, and playback behave differently across Android and iOS.

Keeping these capabilities behind platform-specific interfaces allowed the shared application logic to remain clean while each platform handled its native implementation.

Safe backup and restore

Backup restoration required especially defensive engineering because imported archives must be treated as untrusted input.

Before accepting an archive, Relive validates:

  • File paths
  • File counts
  • Relationships
  • File sizes
  • Metadata
  • Checksums

Restore operations are transactional, so an invalid or interrupted restore cannot silently corrupt the existing archive.

Time-based memories

Features such as On This Day introduced several subtle edge cases:

  • Local calendar boundaries
  • Leap days
  • Future timestamps
  • Anniversary calculations
  • Deterministic daily selections

These features needed to work correctly without sending personal memory data to a remote server.

What I learned

Building Relive taught me that local-first is much more than storing information in SQLite.

It requires deliberate decisions around:

  • Data ownership
  • Secure storage
  • Database migrations
  • Query performance
  • Backup behavior
  • Export formats
  • Privacy boundaries

I also learned how valuable strict architecture boundaries become as a product grows.

Sharing business logic across platforms while isolating native integrations made the codebase much easier to test, maintain, and evolve.

Most importantly, I learned that software designed around personal memories should optimize for trust and emotional longevity rather than attention.

Relive does not try to make people post more.

It tries to make what they already chose to preserve feel meaningful when they encounter it again.

What’s next

The next step for Relive is production polish, including:

  • Broader device testing
  • Accessibility refinement
  • iOS validation
  • Performance profiling with larger archives
  • Final release preparation

The long-term goal remains simple:

Make Relive a beautiful, dependable home for the moments people want to carry forward.

Built With

  • android
  • compose-multiplatform
  • google-drive-api
  • junit
  • kotlin
  • kotlin-serialization
  • local-first
  • material-design-3
  • mobile-development
  • multiplatform
  • revenuecat
  • revenuecat-purchases-kmp
  • sqlcipher
  • sqldelight
  • sqlite
Share this project:

Updates

Submission history