What's New

Today we launched lumiframeapp.com — a public home for LumiFrame ahead of the beta that begins on March 1st.

#What's on the site

Landing page — A proper home that explains what LumiFrame is, who it's for, and how it works. We wanted it to feel as considered as the app, so the same glassmorphism design language carries over.

Waitlist — Sign up to be notified at launch. Early sign-ups will get access to a discounted introductory pricing tier.

Account portal — If you already have a LumiFrame account from the app, you can now sign in at /account and see your profile, stats, and manage basic account settings. It's the first cross-platform web presence for LumiFrame accounts.

This changelog — Eight months of development, documented from concept to today, in one place.

#Cross-platform account sync

The web portal and the mobile app share the same Firebase auth backend. Your profile photo, username, album count, and frame count from the app appear in the web portal automatically. Changes to your display name on the web propagate to the app within the hour.

#What's coming on March 1st

The public beta opens. Anyone can sign up — TestFlight (iOS), direct APK (Android), or from the web. We'll be watching everything closely and shipping fixes daily in the first weeks.

Twenty sprints. Nine months. One more to go before beta. Thank you to everyone who's been part of the journey so far.

For the first time, LumiFrame is in the hands of people who didn't write it. We opened a closed alpha through Apple TestFlight to 50 invited testers — friends, family, and a handful of early sign-ups from the waitlist.

#What we learned in week one

The headline finding: people set up their first frame and album immediately, but many didn't return within 24 hours. The retention curve we wanted wasn't there — the onboarding was good, but there was no "pull" to bring people back the next day.

This immediately shaped our priorities: the Reflections notification timing, the digest cadence, and the default album-assignment prompt all got revisions based on this data.

#Bug fixes from alpha testers

Testers found 43 issues we hadn't seen in internal testing. The most impactful:

• Frame pairing failed on certain Android 14 devices — A permissions change in Android 14 affected background network access during initial pairing. Fixed.
• Albums sticking after contributor removed — When a contributor was removed, their local copy of the album still appeared briefly. Firestore rules enforcement was correct; the local state management wasn't. Fixed.
• Clock mode resuming at wrong brightness — Fixed a state restoration bug where display brightness set via the app wasn't persisted across frame reboots.
• Invitations not delivered to some Gmail addresses — Firebase's email domain was triggering Gmail's spam filter. Resolved by configuring a custom sending domain.
• Video audio playing on frames that should be muted — Frames default to muted per the spec, but a codec path for certain video formats bypassed the mute flag. Fixed.

#Sentry integration

We connected Sentry for crash reporting this sprint. Error capture is already paying dividends — several nil-dereference crashes that were low-frequency enough to have been missed in testing are now captured and tracked.

This sprint made LumiFrame smarter about media: smarter ingestion, smarter selection, and support for formats that matter to the people who care most about their photos.

#Smart media features

AI-assisted highlight selection — The SmartReflectionsEngine now scores photos using on-device image quality signals: blur detection, exposure assessment, and face presence. A technically dark or out-of-focus photo is a less likely Reflection highlight, even if it was recently added. Quality now factors alongside recency and engagement.

Duplicate detection at scale — The perceptual hash pipeline from 0.8 was extended to run across your entire library on first upgrade, not just new uploads. Existing duplicates are flagged and you can review and consolidate them in one action.

Auto-rotate on import — EXIF orientation data is respected on all imported photos. No more upside-down imports from older cameras.

#New format support

HEIC/HEIF — The native photo format from iPhones since iOS 11. HEIC files are now fully supported for upload, display, and thumbnail generation. They're converted on the server side for frame compatibility.

ProRes video — iPhone Pro models can shoot in ProRes. We added a server-side transcoding step that converts ProRes to H.264 before storage, keeping frame playback efficient without requiring the user to pre-convert.

RAW (read-only) — RAW files from mirrorless cameras can be imported. They're used for high-quality JPEG rendering at import time and won't be stored raw (storage costs aside, most frames can't display them natively anyway).

Weekly Reflections were a hit internally — so we extended the system. Monthly Reflections give you a richer, more emotional look back at the full month, and Milestones celebrate the moments worth commemorating.

#Monthly Reflections (Elite tier)

Monthly Reflections run on the first of each month and cover the full 30-day window. Because there's more data to work with, the highlight algorithm can be more selective — surfacing the moments that dominated the month rather than just the week.

Monthly Reflections include:

• Top memory of the month — the single photo or video with the most engagement
• Most active contributor — the person who shared the most this month
• New connections made — people who joined your albums for the first time
• Storage used this month — a light summary of your media activity

#Milestones

Milestones are one-time achievement notifications that celebrate meaningful firsts:

• First shared memory — Your first photo added to a shared album
• First connection — The first person who accepts your invite
• 10, 50, 100 albums — Volume milestones
• Sharing streaks — 2, 4, 8, 12, 24, and 52 consecutive weeks

Milestone cards appear inside Reflections stories, not as separate notifications. They feel like part of your memory — not a gamification overlay.

#Appreciation reactions

A small but meaningful addition: a long-press on any photo lets you send an Appreciation — a quiet thumbs-up delivered to the person who shared it. No reply thread, no like count visible to others. Just a private moment of acknowledgement.

Happy New Year. We started 2026 by solving one of the most frequently requested features from internal testers: getting photos off of cloud storage services and onto your frames without any manual work.

#Dropbox integration (Elite tier)

OAuth connection — Connect your Dropbox account from LumiFrame settings. A secure OAuth 2.0 flow stores only a refresh token — no password, no full access to your Dropbox.

Folder selection — Choose one or more Dropbox folders to sync. LumiFrame monitors them for new photos and videos and imports them automatically to linked albums.

Background sync — Import operations run as a background Cloud Function triggered on a schedule. New photos from Dropbox appear in your albums (and on your frames) without you opening the app.

Import history — A log in settings shows every file imported, when it arrived, and from which folder. Any item can be removed from LumiFrame without affecting the original file in Dropbox.

Conflict handling — Files already in LumiFrame (matched by perceptual hash) are skipped silently rather than creating duplicates.

#Why Dropbox first

Dropbox's OAuth API is mature, well-documented, and widely used among the demographic who would own a digital frame. Google Photos integration is planned — it requires navigating a more restrictive API review process that we're working through now.

The holidays felt like the right moment to step back from features and make everything more beautiful. This sprint was a full UI pass — new design language, new onboarding, and the kind of polish that makes an app feel considered.

#Design language: Glassmorphism

We adopted a glassmorphism visual language: frosted glass panels, translucent layers, soft violet gradients, and generous blur effects. The result is a UI that feels premium without being heavy. Every screen now has visual depth.

Key tokens formalised this sprint:

• Blur radius: 12–24px for panels, 40px for modal overlays
• Primary accent: #7C3AED violet with a soft glow
• Glass surface: white/8–12% opacity over a dark base layer
• Radius: 20–28px for cards, 16px for buttons

#Onboarding redesign

The original onboarding was functional but forgettable. The new flow:

1. Welcome screen — Full-bleed ambient video showing LumiFrame in a real home
2. What is LumiFrame? — Three illustrated feature cards, swipeable
3. Account creation — Streamlined to three fields, social login first
4. First frame setup — Guided pairing with helpful illustrations at each step
5. First album — Prompt to add photos immediately; the first win comes fast

#Animation system

We formalised an animation library: LumiEntranceAnimation, LumiVisibility, LumiPressable, LumiPulse. Consistent easing and duration tokens replace scattered custom animations across the codebase. The app now feels unified in motion.

Happy holidays from the LumiFrame team. Back in the new year with more to show.

LumiFrame needs to sustain itself. This sprint introduced the subscription tiers that fund continued development while keeping the core experience genuinely useful for free.

#The tier structure

Free

• 1 frame, 2 albums
• 5GB cloud storage
• Standard slideshow transitions
• Weekly Reflections

LumiFrame+

• Unlimited frames and albums
• 50GB cloud storage
• Premium transition styles
• Custom clock themes
• Priority sync

Elite

• Everything in LumiFrame+
• 250GB cloud storage
• Dropbox and Google Photos import
• Monthly Reflections with extended history
• Early access to new features

#What shipped under the hood

RevenueCat integration — In-app purchases go through RevenueCat for server-side receipt validation, cross-platform entitlement management, and subscription lifecycle webhooks.

AccessTierService — A single service in the app that gates every premium feature. No feature checks are scattered across the codebase; they all route through here. Changing a tier rule is a one-line change.

Paywall UI — A contextual paywall appears when a free-tier user attempts a premium action. It's informative rather than aggressive — it explains what they'd unlock without blocking the rest of the app.

Server-side enforcement — Firestore rules and Cloud Functions enforce tier limits independently of the client. You can't exceed your storage quota by bypassing the app.

Pricing will be announced at launch. Alpha testers will receive a significant early-adopter discount.

The question we kept hearing during internal testing: what's the point of a shared album if nobody looks back at it? Reflections is our answer.

#What shipped

Weekly Reflections — Every Monday morning, LumiFrame generates a personalised story summarising the past week of shared memories. Rendered as an immersive full-screen experience with music-sync timing and smooth transitions, it feels more like a living scrapbook than a data summary.

Smart highlight selection — The SmartReflectionsEngine scores every piece of media from the past week based on: number of unique viewers, reactions received, recency, and media quality. The top highlights are selected automatically — no curation required.

Sharing streaks — Weeks in a row where you actively added photos to shared albums earn a streak counter. Streaks are surfaced in your Reflection with small milestone celebrations at 2, 4, 8, and 12 weeks.

Nudge intelligence — If your Reflection detects a pattern worth surfacing — a collaboration that has gone quiet, a frame that hasn't been updated in two weeks, a new connection who hasn't been invited to any albums — it includes a gentle, contextual nudge with a one-tap action.

#Why we built this

Daily active engagement with a digital frame requires something that draws you back. Reflections creates a weekly reason to care — that feeling of "oh, I forgot about that moment" driving you to add more, share more, and connect the frame to more of your life.

After five months of feature sprints, we took a full two weeks to do nothing but make LumiFrame faster and more reliable. The output was significant.

#Performance improvements

Cold start time reduced by 38% — We profiled the startup path and identified three blocking operations that could be deferred. The app now reaches a usable state in under 1.8 seconds on a mid-tier Android device.

Memory footprint at steady state — Long-running frame sessions were showing memory growth over 48+ hours. We rewrote the media cache eviction strategy using an LRU policy with explicit size limits. A 72-hour soak test now shows a flat memory graph.

Firestore read cost audit — We audited every Firestore read the app performs and eliminated 14 redundant reads that were firing on every navigation event. An in-memory cache layer now serves repeated lookups of stable data.

Image render pipeline — Thumbnails were being decoded on the main thread in some grid layouts. Moved all decode operations to a background isolate. Grid scrolling is now consistently 60fps on all test devices.

#Stability fixes

• Fixed a race condition in the upload queue that could cause a photo to be uploaded twice
• Fixed frame status listener not resuming after app moves to background and returns
• Fixed crash when opening an album that was deleted by another user while you were viewing it
• Fixed notification delivery failing silently when FCM token refresh coincided with a cold start
• 23 additional minor fixes surfaced from internal dogfooding

#What we learned from this sprint

Every product benefits from a dedicated stability sprint before user growth. These fixes would have been much harder to isolate with real users filing confusing bug reports. Take the time.

If one frame is good, several should be even better. This sprint we added the ability to organise frames into groups — essential for households with displays in multiple rooms.

#What shipped

Frame groups — Create named groups ("Downstairs", "Bedroom", "Office") and assign any combination of your frames to them. Groups appear alongside individual frames in the app.

Broadcast playback — Set an album on a group and all frames in that group update simultaneously. This is the most common multi-frame use case: your entire home showing the same family album.

Per-group settings — Display interval, transition style, and brightness can be set at the group level and inherited by member frames. Per-frame overrides are still available when you need them.

Group slideshow commands — Play, pause, and next-photo commands issued to a group propagate to all member frames in under 200ms.

Frame group management — Add or remove frames from a group at any time. A frame can belong to multiple groups simultaneously.

#Implementation note

Group commands are implemented as a fan-out write in Cloud Functions: a single command document triggers a Function that writes individual command documents to each member frame. This keeps the client simple (one write) while maintaining the per-frame audit trail needed for debugging connectivity issues.

Frames aren't always actively displaying photos. This sprint we made the idle state worth looking at.

#What shipped

Clock mode — When a frame has no album assigned, or when you pause the slideshow, it switches to a full-screen clock display. Three styles available: Minimal (time only, light type on a dark background), Detailed (time, date, and day of week), and Analog (rendered clock face).

Auto-dim schedule — Set a time range during which the frame display dims to a user-configurable brightness level. Perfect for preventing a bright screen from lighting up your bedroom at 2am. The schedule is configured per-frame from the app.

Sleep mode — Fully power down the display on a schedule. The frame software continues running so it can wake on command or on schedule.

Display brightness control — Manual brightness slider per frame, adjustable from the app without touching the frame.

Screensaver mode — Rather than showing a static clock, you can configure the frame to show a slow-motion ambient loop — a gentle gradient animation that's restful without being blank.

#Why this matters for daily use

A digital frame that goes dark or shows a jarring screensaver at night is a frame that gets unplugged. The ambient experience needed to feel intentional from day one. Clock mode alone dramatically increases the hours-per-day a frame is genuinely pleasant to have in the room.

LumiFrame is fundamentally a social product — shared memories between people who know each other. This sprint invested in the social infrastructure that makes that meaningful.

#What shipped

Profile photo upload — Upload a profile photo directly from your camera roll. The image is processed through the same R2 thumbnail pipeline used for album media: three sizes generated, the smallest used in contributor lists and notifications, the largest shown on your profile.

@username handles — Every user has a unique, lowercase handle. Handles are 3–30 characters, alphanumeric with underscores only, and reserved against a list of protected names. Once claimed, handles are permanent.

Follow system — You can follow other LumiFrame users to see their public activity in your feed. Following is one-way (like Twitter, not Facebook). Follower and following counts are tracked in users/{uid}/public/metrics for efficient reads.

User search — Search by display name or @username to find people you know. Results are limited to public profiles.

Connection invitations — When you invite someone to a shared album by username, they see who you are before accepting. The social graph makes this more trustworthy than an anonymous invite link.

#What this enables

The social layer isn't a vanity feature — it's what will power Reflections (coming in a future sprint): a personalised weekly recap of the memories you've shared with the people you're connected to.

Media needs to be everywhere — on your phone, cached on your frame, and backed up safely in the cloud. This sprint we rebuilt the sync layer from scratch with a proper architecture instead of the rough prototype from 0.4.

#What shipped

Two-way sync engine — Changes made on any device propagate to all others within seconds. The frame doesn't poll; it listens to Firestore for change events and fetches only the delta.

Offline queue — Photos added while offline are queued locally and uploaded automatically when connectivity restores. The queue is persistent across app restarts and handles partial uploads gracefully.

Storage quotas — Each account tier has a storage ceiling. The app shows a live storage usage indicator in settings and warns at 80% and 95% capacity. Uploads are gated at the limit.

Media deduplication — A perceptual hash is computed client-side before upload. If the same photo already exists in your library, the upload is skipped silently. This alone cut storage costs in our internal testing by around 18%.

Thumbnail generation pipeline — Cloud Functions listen for new media uploads in R2 and generate three sizes: 256px (avatar/UI), 512px (grid), and 1080px (frame quality). All three are stored alongside the original.

#Numbers from this sprint

• Average media sync latency: 1.2 seconds phone → frame
• Upload throughput: ~8 photos/sec on a typical home broadband connection
• Offline queue recovery: 100% success in test scenarios up to 500 queued items

LumiFrame now tells you when things happen. Push notifications seem straightforward until you think about all the ways they can go wrong — stale tokens, duplicate sends, notification fatigue. We spent this sprint getting them right rather than just getting them shipped.

#What shipped

New photo notifications — When a contributor adds a photo to a shared album, all other members receive a quiet notification: "Jamie added 3 photos to Summer Trip."

Frame status alerts — If a frame you own goes offline for more than 5 minutes, you get a notification. When it comes back online, another one. Both are off by default; opt in from frame settings.

Digest mode — For users in active shared albums, individual notifications can get noisy. Digest mode batches album activity into a single daily summary instead of per-upload notifications.

FCM token lifecycle — Tokens are registered on login, refreshed when they expire, and cleaned up on sign-out. Multiple devices per account are supported — each gets targeted notifications individually.

#What we didn't ship

We deliberately skipped marketing/promotional notifications for now. We'll earn the right to that channel by delivering consistently useful in-product notifications first. Users who never found notifications annoying are users who stick around.

LumiFrame is meant to be shared. This sprint introduced the collaboration model that makes it possible for a whole family to contribute to a frame — with clear boundaries around what each person can do.

#What shipped

Contributor roles — Three levels: Viewer (can see the album), Contributor (can add and remove their own photos), Admin (full album management including inviting others and changing settings).

Invite by link — Generate a shareable invite link for any album. Recipient taps the link, creates or signs in to their account, and they're in at the role you specified. Links expire after 7 days.

Pending invite management — Album admins can see pending invites, cancel them, and resend them. Invitees see their pending and accepted invitations in one place.

Contributor photo attribution — Every photo in a shared album shows who added it. Names and avatars appear in the media detail view.

Remove contributors — Admins can remove a contributor. Their previously uploaded photos optionally stay (owner decides).

#On the data model

We store contributor state in users/{owner_uid}/albums/{albumId}/contributors/{contributorUid}. This keeps album ownership clear — the album lives under the owner, not in a neutral shared space — while still letting contributors query their own memberships. It's unconventional but it scales.

Photos are on the frame. Now they needed to look great in motion. This sprint was all about the playback experience — the thing users will stare at every single day.

#What shipped

Custom slideshow engine — We wrote VideoPlayerManager and PlaybackCoordinator from scratch rather than using any off-the-shelf slideshow library. This gives us full control over prefetching, memory management, and transition timing.

Transitions — Five transition styles available: fade, slide, scale, dissolve, and Ken Burns (slow pan and zoom for photos). Transitions are configurable per album.

Playback settings — Display interval (5 seconds to 5 minutes), shuffle mode, loop, and fit/fill behaviour for different aspect ratios.

Tap to pause / swipe to advance — Gesture controls on the frame display itself for moments when you want to linger on a photo or skip ahead.

Preloading — The next 3–5 items in the queue are pre-decoded in memory so transitions are instantaneous. This was the single biggest perceived-quality improvement of the sprint.

#Why we built our own

Third-party slideshow packages either couldn't handle mixed photo/video sequences reliably, or they introduced memory leaks at longer runtime. For a frame that runs 24/7, memory stability isn't optional. Our engine was battle-tested across a 72-hour continuous run before we called it done.

You can now add photos and videos to LumiFrame. This sprint was the most feature-dense one so far and required deep coordination between the Firestore data model, Cloudflare R2 storage, and the app UI.

#What shipped

Albums — Stored in users/{uid}/albums. Each album has a title, cover photo, visibility setting, and metadata. Albums can be assigned to one or more frames.

Photo and video upload — Media flows from your camera roll through a signed upload URL to Cloudflare R2. Thumbnail generation happens server-side via a Cloud Function triggered on upload. The app stores a reference in users/{uid}/media linking the R2 key to the album.

Media grid — A responsive grid in the app showing your photos and videos per album, with lazy loading and smooth scroll performance.

Assign album to frame — Tap a frame, pick an album. The frame starts pulling and displaying that album's media within seconds.

#Storage architecture

We settled on a tiered storage approach:

• Thumbnails (256–512px) served from media.lumiframeapp.com CDN — fast, cached, cheap
• Full resolution served via time-limited signed URLs for privacy
• Frame-quality renditions generated at upload and cached for frame delivery

Getting this pipeline right early means we won't need to migration media later. It already feels solid.

LumiFrame is finally living up to its name. This sprint we built the core of the product: connecting a display to your account.

#What shipped

QR code pairing — The LumiFrame client running on a display generates a time-limited QR code. Scan it with your phone and the frame is instantly added to your account. No IP addresses, no network configuration, no cables.

Frame registration in Firestore — Each paired frame gets a document at users/{uid}/remote_frames/{frameId} containing its name, status, last-seen timestamp, and assigned album. The phone updates this document; the frame listens for changes and reacts immediately.

Frame health monitoring — Frames report their online/offline status on a heartbeat interval. The app surfaces a badge when a frame goes offline so you always know what's happening.

Rename and delete frames — Basic management from the app: rename a frame to something meaningful ("Living Room", "Kitchen"), or remove it from your account entirely.

#What we learned

The hardest part wasn't the QR code — it was ensuring the frame's Firestore listener recovers gracefully after a network dropout. We wrote a reconnect strategy with exponential backoff that will become increasingly important as we add more real-time features.

Next up: the media side. Albums, uploads, and getting photos onto the frame.

You can now create an account in LumiFrame. That sounds modest, but the auth system we built this sprint is the backbone everything else will be built on.

#What shipped

Sign-up flow — Three-step onboarding: email + password, then display name and @username claim, then you're in. Usernames are globally unique, enforced both client-side and in a Firestore usernames registry to prevent races.

Google Sign-In — OAuth with Google works end-to-end, including the edge case where a Google-authenticated user and an email user could theoretically collide on the same address. Handled safely.

Firestore user document — Every user gets a users/{uid} document that stores displayName, username, email, tier, photoUrl, and timestamps. This doc is the source of truth across every platform that will ever know about this user.

Security rules — Firestore rules written from the start, not bolted on later. Users can only read and write their own documents. Username registry is append-only from clients.

#Under the hood

We made a deliberate call to require email verification before most write actions are permitted. OAuth providers (Google, Apple) are auto-verified. Password users must confirm their email. This small friction point eliminates a large class of abuse.

Next sprint: frame connection — the core product feature that makes all of this worth building.

Today the first real line of LumiFrame code was committed. After a month of planning, we had enough conviction in the architecture to start building.

We chose Flutter for the mobile client — one codebase for iOS and Android, with the performance profile needed for smooth media playback. Firebase was the obvious choice for the backend: Firestore for real-time data, Firebase Auth for identity, and Cloud Functions for server-side logic that the phone should never touch directly.

#What landed in 0.1

• Flutter project initialised with a clean folder structure (controllers/, services/, screens/, models/)
• Firebase project created: lumiframe-1
• Firebase Auth wired up with email/password sign-in
• Basic GetX navigation shell with placeholder screens
• CI pipeline configured for automated builds on every push
• Cloudflare R2 bucket provisioned for media storage

It doesn't do much yet. But the foundation is right, and in early-stage development, that matters more than features.

The next sprint is authentication — user accounts, usernames, and the profile document that will follow a user across every device and platform they ever use.