Hello Gallery — A Modern Desktop Media Gallery
A cross-platform desktop gallery application built with Flutter and Dart, designed for browsing, organizing, and viewing local photos and videos. Features customizable gallery layouts, advanced media playback, real-time filesystem updates, and keyboard and gamepad navigation.
The story
Overview
Hello Gallery is a desktop-first photo and video gallery application built with Flutter and Dart for Windows and macOS.
The application provides a fast, customizable environment for browsing, organizing, and viewing local media files without requiring cloud storage or an internet connection for core gallery functionality.
It combines flexible gallery layouts, advanced image viewing, video playback, and filesystem integration within a single desktop interface.
The project focuses on delivering a responsive desktop experience while maintaining an architecture that supports future improvements and platform-specific capabilities.
The Idea
Managing photos and videos across multiple folders can become inconvenient, especially when switching between file explorers, image viewers, and video players.
I wanted to build an application that brings these activities together into one consistent experience.
The idea behind Hello Gallery was to create a media gallery that feels lightweight, customizable, and comfortable to use on a desktop.
Rather than copying a traditional file manager, the application focuses on visual media browsing, convenient navigation, and direct interaction with local files.
Another important goal was to explore Flutter's capabilities beyond mobile development, particularly its potential for building desktop applications that interact with native operating-system features.
Key Features
1. Local Media Library
Hello Gallery allows users to browse photos and videos directly from folders stored on their computers.
Users can select a root gallery folder and navigate its contents through multiple navigation methods.
Key capabilities include:
- Browsing local folders and subfolders.
- Breadcrumb navigation.
- Folder navigation history.
- Expandable directory tree.
- Natural filename and modification-date sorting.
- Automatic detection of filesystem changes.
- Persistent root-folder preferences.
The application keeps media files on the local machine rather than uploading them to a remote service.
2. Customizable Gallery Layouts
The gallery provides multiple layout options to accommodate different viewing preferences.
Supported layouts include:
- Standard grid.
- Aspect-ratio grid.
- Quilted layout.
- Masonry layout.
Users can customize thumbnail sizes, item spacing, corner radius, filename labels, and folder previews.
These options make it possible to adjust the gallery for different screen sizes, media collections, and personal preferences.
3. Advanced Image Viewer
Hello Gallery includes a dedicated image-viewing experience with interactive controls.
Users can:
- Zoom in and out of images.
- Pan around enlarged images.
- Rotate images.
- Switch to fullscreen mode.
- Navigate between adjacent media files.
- Use keyboard shortcuts and mouse interactions.
Adjacent media preloading helps reduce interruptions when navigating through a collection.
The viewer supports common image formats, including JPEG, PNG, GIF, WebP, BMP, HEIC, and TIFF, subject to platform decoding capabilities.
4. Video Playback
The application integrates media_kit for local video playback.
It provides a customized video-viewing interface with controls for:
- Play and pause.
- Seeking through video content.
- Volume and mute.
- Loop playback.
- Video rotation.
- Fullscreen viewing.
- HDR toggle.
- Clean viewing mode.
- Navigable media filmstrip.
The application also generates video thumbnails and timestamp-aware preview frames to help users navigate video content.
5. Media and File Management
Hello Gallery includes essential file-management operations to help users organize their local media libraries.
Users can:
- Select multiple files.
- Rename media files and folders.
- Move files between folders.
- Group selected items.
- Send files and folders to the operating system's native trash.
These operations are integrated into the gallery interface, reducing the need to switch to an external file manager for common organizational tasks.
6. Keyboard and Gamepad Navigation
One of the distinctive features of Hello Gallery is its support for multiple input methods.
In addition to mouse and keyboard interactions, the application supports Xbox-style and PlayStation-style gamepads.
Gamepad features include:
- Navigating gallery items using the directional pad.
- Opening selected media.
- Controlling video playback.
- Switching fullscreen mode.
- Scrolling through content.
- Controlling a virtual cursor using the right analog stick.
- Performing clicks and drag operations.
- Adjusting cursor precision.
This makes the application suitable for users who prefer controller-based navigation, including desktop setups connected to larger displays.
7. Appearance and Personalization
Hello Gallery provides configurable appearance settings designed to adapt to different desktop environments.
Users can choose between:
- Light theme.
- Dark theme.
- System appearance.
- Customizable color themes.
Gallery presentation preferences and the selected root folder are stored locally, allowing the application to restore the user's configuration between sessions.
Technical Architecture
Hello Gallery follows a feature-first architecture with clear boundaries between presentation, application, domain, and data responsibilities.
This structure helps separate interface components from business rules and platform-specific operations.
Frontend and Application Framework
The application is developed using Flutter and Dart.
Flutter provides a shared UI framework for Windows and macOS, enabling consistent application behavior while supporting platform-specific integrations.
The interface includes gallery views, media previews, navigation components, settings, and custom input controls.
Feature-Based Organization
The codebase is organized around independent application features.
Major modules include:
- Gallery: Media browsing, selection, folder navigation, and organization.
- Gamepad: Controller input normalization and virtual cursor behavior.
- Media Index: Filesystem monitoring and incremental updates.
- Media Preview: Image viewing and video playback.
- Settings: Appearance, folder preferences, and persistent configuration.
- Thumbnail: Thumbnail generation, scheduling, and caching.
Each feature separates presentation logic, application services, domain rules, and data access where appropriate.
Media Processing and Caching
Large media collections require efficient handling to maintain smooth scrolling and navigation.
Hello Gallery uses scheduled and bounded thumbnail and preview processing to control resource usage.
Generated thumbnails are cached using media identity and file metadata.
When source files change, the application can invalidate outdated cache entries rather than displaying stale thumbnails.
Native Platform Integration
The application integrates with native operating-system functionality for local file access and media handling.
On macOS, security-scoped bookmarks are used to restore access to previously selected folders.
On Windows, the project includes an Inno Setup configuration and PowerShell build helper to package the application into an installer.
Video Playback Engine
Video playback is implemented using media_kit, which provides the media capabilities required for the application's custom playback interface.
The application builds additional navigation, filmstrip, preview, and playback controls around this integration.
Engineering Challenges
Maintaining Performance with Large Media Libraries
A major challenge in developing a media gallery is handling large collections of photos and videos without making the interface unresponsive.
Loading every file and generating every thumbnail immediately can create unnecessary processing and memory overhead.
To address this, the application uses bounded thumbnail scheduling, caching, and incremental filesystem updates.
These mechanisms help distribute media-processing work while keeping navigation responsive.
Integrating Native Filesystem Behavior
Desktop applications must handle filesystem operations and operating-system permissions differently from typical web applications.
Hello Gallery interacts with local folders, monitors filesystem changes, and performs file-management operations.
The application also accounts for platform-specific requirements, including macOS folder-access permissions and Windows installation packaging.
Building a Custom Media Viewer
Supporting images and videos within the same application requires coordinating different rendering and interaction behaviors.
Image viewing emphasizes zooming, panning, and rotation, while video playback requires timeline navigation, playback state, and media controls.
The project combines these capabilities into a consistent media-preview experience.
Supporting Multiple Input Methods
Designing an interface that works with a keyboard, mouse, and gamepad introduces additional interaction complexity.
Gamepad navigation requires translating controller input into meaningful interface actions, including selection, scrolling, cursor movement, and media playback.
The application uses normalized controller input and a virtual cursor to support these interactions.
Designing for Multiple Desktop Platforms
Although Flutter provides a shared application framework, Windows and macOS still have different native capabilities and integration requirements.
The project therefore uses platform-specific implementations where necessary while keeping the application structure consistent.
Windows remains the primary development target, with macOS support included in the codebase.
What I Learned
Developing Hello Gallery provided an opportunity to explore desktop application engineering using Flutter and Dart.
The project involved several technical areas beyond conventional UI development, including filesystem operations, media decoding, thumbnail processing, caching, native platform integration, and controller input.
It reinforced the importance of designing application architecture around clear feature boundaries, especially when working with functionality that depends heavily on the operating system.
The project also highlighted the value of performance-conscious development. Media-heavy applications benefit from careful scheduling, caching, and incremental updates rather than unnecessary work during every navigation action.
Future Improvements
Hello Gallery is actively being developed, with several areas identified for further improvement:
- Improving video seek-preview responsiveness.
- Expanding compatibility and reliability across different video codecs.
- Optimizing performance for larger media libraries.
- Expanding platform-level integration testing.
- Continuing to refine the desktop media-browsing experience.
These improvements will help strengthen application reliability and improve the experience across supported desktop environments.
Conclusion
Hello Gallery demonstrates how Flutter can be used to build a feature-rich desktop application that goes beyond conventional mobile interfaces.
By combining local media management, customizable gallery layouts, advanced media viewing, and native platform integration, the project aims to provide a practical environment for organizing and enjoying personal media collections.
The project reflects a focus on desktop software architecture, responsive user interfaces, efficient media processing, and thoughtful interaction design.