English · Español · Português (BR)

FlutterGuide: Mobile App

An Android app for browsing Flutter/Dart widgets, functions, and packages, each with runnable code and a live preview.
Explore the docs »

View Website · Report Bug · Request Feature

Table of Contents

• About The Project
• Features
• Built With
• Architecture
• Testing
• Screenshots
• Download the App
• Getting Started
• Scripts
• Documentation
• Contributing
• Changelog
• License
• Author

About The Project

FlutterGuide is a mobile catalog of Flutter and Dart building blocks, built to help both beginner and experienced developers learn by example.

Each entry (widget, function, or package) ships with its source code and a live, interactive preview rendered right in the app, so you can see the behavior before copying it into your own project. The catalog also includes ready-made UI screens and reusable interface elements for common app patterns.

The catalog currently covers:

Category	Count
Widgets	131
Packages	42
Functions	13
Elements	10
UI samples	6
Total	202

Features

• Widget, Function & Package Catalog: Browse Material and Cupertino widgets, core Dart functions, and popular packages, each with code, an interactive preview, and a link to the official docs.
• Elements & UI Samples: Full sample screens (login, chat, email client, and more) and reusable interface elements you can study or copy.
• Favorites: Save any widget, function, or package for quick access later.
• Search: Filter each catalog by name as you type.
• Deep Linking: Open a specific component or sample directly from a shared link.
• Multiple Languages: Full app UI in English, Portuguese (Brazil), and Spanish.
• Code Theme Selector: Pick the syntax-highlighting theme used for code samples, with light and dark variants.
• Light & Dark Theme: App-wide theming with a persisted preference.
• Accessibility: Semantic labels on interactive elements for screen readers.

Built With

• Flutter: Google's UI toolkit for building natively compiled applications from a single codebase.
• Dart: The programming language behind Flutter.
• Riverpod: State management and dependency injection.
• go_router: Declarative routing and deep link handling.
• flutter_syntax_highlighter: Syntax highlighting for the code samples.
• shared_preferences: Persisting theme, language, and code theme selections.
• google_mobile_ads: Ad monetization.
• app_links: Deep link handling.
• intl and Flutter's built-in l10n tooling: English, Portuguese (BR), and Spanish localization.
• mocktail: Mocking in the test suite.

The in-app catalog also demonstrates dozens more packages, such as dio, http, cached_network_image, flutter_svg, video_player, flutter_animate, photo_view, and shimmer; open the Packages tab in the app for the full, runnable list.

Architecture

The app is organized by feature (lib/src/features/), each with its own data, domain, and presentation layers:

• catalog: the widget/function/package/element/UI catalog, search, and favorites.
• home: the landing screen and component groups.
• settings: language selection and app info.
• code_theme_selector: the code sample syntax-highlighting theme picker.

State is managed with Riverpod (ViewModel/Notifier classes exposed through providers), routing with go_router, and persistence through a SharedPreferences-backed service layer. Shared, feature-agnostic widgets live under lib/src/shared; cross-cutting concerns (DI, routing, theming) live under lib/src/core.

For the layering rules, the subsystems and the decisions behind them, see docs/architecture.md.

Testing

The app has 68 test files and 378 test cases covering repositories, view models, notifiers, the root widget, deep link handling, localization and shared widgets, using mocktail for mocking and ProviderContainer overrides for Riverpod state. packages/app_ui has 7 more files and 24 cases of its own. Code is linted against the strict very_good_analysis rule set.

Line coverage is 97.8% for the app, measured over lib/ minus the generated sources and the catalog samples, which are teaching code rendered to the user rather than app logic, and 100% for packages/app_ui. The two gates fail below 95% and 98%, and each package is measured on its own.

One command runs everything CI runs, in the same order:

./scripts/verify.sh

See docs/contributing.md for what each step catches and which CI job blocks a merge.

Screenshots

Download the App

Get FlutterGuide directly from the Google Play Store:

Getting Started

The project pins its Flutter SDK version via FVM, so all commands below use fvm flutter rather than a bare flutter install.

git clone https://github.com/dariomatias-dev/flutter_guide_app.git
cd flutter_guide_app
fvm install
fvm flutter pub get

Create a .env file in the project root (it's git-ignored) with the following keys; leave values empty for a local run without ads:

DEVICE_ID=
BANNER_AD_ID=
BANNER_AD_SAMPLE_ID=
INTERSTICIAL_AD_SAMPLE_ID=
REWARDED_AD_SAMPLE_ID=
APP_OPEN_AD_SAMPLE_ID=

Then run the app on a connected device or emulator:

fvm flutter run

Scripts

Utility scripts live under scripts/.

Script	Command	Description
verify	scripts/verify.sh [--all] [--skip-tests]	Runs the same gate CI enforces: regenerates the localizations and fails if the committed output was stale, checks ARB parity, then format, analyze, tests and the coverage threshold. Only runs when the working tree has pending changes under the code it covers, unless --all is passed.
check_coverage	scripts/check_coverage.sh <lcov-file> <minimum>	Fails when line coverage falls below the minimum, excluding generated sources and the catalog samples under lib/src/features/catalog/data/samples/, which are teaching material rendered to the user rather than app logic.
check_l10n	scripts/check_l10n.sh [arb-dir]	Fails when the ARB files disagree on which keys they carry, or when a key in the template ships without a description. gen-l10n falls back to the template silently, so nothing else catches a half-translated change.
workspace_hash	scripts/workspace_hash.sh	Prints a hash of the sources the gate covers. verify.sh records it in .dart_tool/verify_stamp so tooling can tell whether the tree still matches a passing run.
screenshot	scripts/screenshot.sh [device-id]	Drives the app through its main screens on a connected device or emulator, in all three locales, saving each screenshot under screenshots/<locale>/. The English set is what this README, the Play Store listing and the official website use. Run fvm flutter devices to list available device ids.

Documentation

Document	What it covers
Architecture	Layout, layering rules, and the decision behind each subsystem
Contributing	Setup, the local gate, what CI checks, releases, and the commit convention
Security policy	How to report a vulnerability privately, and what is in scope
Code of Conduct	Behaviour expected in project spaces
Working agreement	The process every change follows, whether it comes from a person or an agent
Design system	What packages/app_ui holds, and the boundary that keeps it app-agnostic

Each is also available in Español and Português (BR), with a language switcher at the top of every page.

Contributing

Contributions make the open-source community an amazing place to learn and create. Any contributions you make are greatly appreciated.

Before opening a pull request, see docs/contributing.md for the local setup, the quality gate, the commit message convention (Conventional Commits), and the branching rules this project follows. Participation is covered by the Code of Conduct.

Found a security issue? Do not open a public issue: follow the security policy.

Changelog

All notable changes are documented in CHANGELOG.md, following the Keep a Changelog format.

License

Distributed under the MIT License. See the LICENSE file for more information.

Author

Developed by Dário Matias Sales:

• Portfolio: dariomatias-dev
• GitHub: dariomatias-dev
• Email: dariomatias.dev@gmail.com
• Instagram: @dariomatias_dev
• LinkedIn: linkedin.com/in/dariomatias-dev