Flutter Fundamentals
Flutter is a user-interface toolkit for building mobile, web, and desktop applications from a shared Dart codebase. You compose widgets to describe each screen, while Flutter supplies rendering, input, accessibility, and platform integration.
itMobile and client application development | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Flutter Fundamentals
Flutter is a way to describe an application interface in Dart and let one framework carry that description toward mobile, web, and desktop targets. It is not a magic button that turns one screen into several perfect products. It is more like a very capable stage crew: you provide the script, and it moves the scenery, paints the set, handles the applause, and occasionally asks which theater you meant.
The key idea is the widget tree, a hierarchy of immutable interface descriptions. Text, padding, buttons, themes, and navigation all join the same family tree, which is unusually civil for a group that includes both a button and the empty space around it. When application state changes, Flutter receives a new description and reconciles it with the runtime structures already in use.
Those runtime structures are the useful surprise. A widget is not the thing painted on screen. An element keeps a location and identity across frames, while a render object does the layout, painting, hit testing, and accessibility work. That distinction is why rebuilding a widget does not mean throwing the whole screen into a skip. It also explains why work placed in build can hurt: build may happen often because it describes the current state, not a one-time construction ceremony.
Local state belongs near the interface that depends on it. A StatefulWidget keeps mutable local data across rebuilds; a StatelessWidget has no such private drawer. Once several screens need the same changing data, give it a clear owner and separate the interface layer from the data layer. Choosing a state package before answering who owns what is rather like buying shelves before checking which room has the wall.
Flutter shares code, not responsibility. Packages and plugins can reach device features, and platform channels can connect Dart to host code when no plugin fits. Each target still has its own conventions, permissions, signing, release behavior, and tests. Hot reload makes eligible Dart changes appear quickly while preserving state, but it does not rerun main or state initialization, and it cannot replace a restart for native changes.
For the fuller map, open the intro for the layers and boundaries, the slides for the relationships, and the cheatsheet when choosing widgets, navigation, tests, or restart levels. Then use the practice reference and exercise to make one visible state change and prove it with a widget test. That small loop is the part where the stage crew stops being a diagram and starts earning its tea.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://flutter.dev/
Supports
- Flutter is a framework and toolkit for building applications with Dart
- Flutter targets mobile, web, and desktop platforms
- https://docs.flutter.dev/learn/pathway
Supports
- Flutter uses the Dart programming language
- The official pathway covers installation, Dart, widget fundamentals, layout, state, networking, navigation, DevTools, and Flutter internals
- https://dart.dev/language
Supports
- Dart programs use a top-level main function as an entry point
- Dart supports variables, control flow, functions, classes, imports, and asynchronous programming
- https://docs.flutter.dev/resources/architectural-overview
Supports
- Flutter is a reactive and declarative user-interface framework
- Widgets are immutable descriptions composed into a hierarchy
- Elements persist across frames and associate widgets with render objects
- Render objects handle layout, painting, hit testing, and accessibility
- The Flutter stack includes a Dart application, framework, engine, embedder, and runner
- Flutter implements its own controls instead of delegating every control to the operating system
- BuildContext identifies a widget location in the element tree
- https://docs.flutter.dev/data-and-backend/state-mgmt/intro
Supports
- Flutter documents several approaches for managing state shared across an application
- State management concerns the structure and flow of changing application data
- https://docs.flutter.dev/ui/navigation
Supports
- Navigator displays routes as a stack
- Router supports more specific deep-linking and browser address-bar requirements
- Current Flutter guidance does not recommend named routes for most applications and points to go_router or Navigator alternatives
- https://docs.flutter.dev/packages-and-plugins/using-packages
Supports
- A Dart package contains a pubspec.yaml file and can contain code, resources, tests, and dependencies
- A plugin package exposes platform functionality to a Flutter application
- Published Flutter-compatible packages are discoverable through pub.dev
- Packages and plugins can support different combinations of Flutter targets
- https://docs.flutter.dev/platform-integration/platform-channels
Supports
- Platform channels pass asynchronous messages between Dart and host-platform code
- Flutter documents host integrations using Kotlin, Java, Swift, Objective-C, C++, and C
- Web platform integration commonly uses Dart and JavaScript interoperability
- Pigeon can generate type-safe platform-specific channel code
- https://docs.flutter.dev/tools/hot-reload
Supports
- Hot reload injects eligible Dart changes in debug mode and rebuilds the widget tree while preserving state
- Hot reload does not rerun main or initState
- Hot restart loses application state, and native-code changes require a full restart
- https://docs.flutter.dev/testing/overview
Supports
- Flutter testing includes unit, widget, and integration tests
- Unit tests cover functions, methods, or classes; widget tests cover widgets; integration tests cover complete applications or large flows
- Official guidance favors many unit and widget tests plus enough integration tests for important use cases
- https://docs.flutter.dev/perf/best-practices
Supports
- Build methods can run frequently and should avoid repetitive expensive work
- Localizing setState limits the subtree that rebuilds
- Const constructors can reduce rebuild work
- Flutter DevTools includes a performance view for measurement
- https://docs.flutter.dev/ui/accessibility
Supports
- Flutter includes framework accessibility support in addition to operating-system support
- Accessibility should be included in application design and release criteria
- https://docs.flutter.dev/app-architecture/guide
Supports
- Flutter architecture guidance separates user-interface and data layers
- The guidance describes views, view models, repositories, services, and an optional domain layer
- The architecture recommendations are adaptable guidelines rather than mandatory rules
- https://docs.flutter.dev/reference/supported-platforms
Supports
- Flutter documents supported and continuously tested operating-system and browser combinations for each release
- https://github.com/Solido/awesome-flutter
Supports
- The fetched Awesome Flutter list includes Riverpod, Bloc, Flame, Patrol, and Melos as ecosystem resources
- https://riverpod.dev/
Supports
- Riverpod documents declarative state, asynchronous loading and error handling, testing support, linting, refactoring, and DevTools integration
- https://bloclibrary.dev/
Supports
- Bloc is a state-management library for Dart with concepts, architecture, testing guidance, tutorials, and sample applications
- https://flame-engine.org/
Supports
- Flame is a game engine built on Flutter for mobile, desktop, and web
- https://patrol.leancode.co/
Supports
- Patrol is an end-to-end Flutter testing framework with native interaction and device-farm support
- https://melos.invertase.dev/
Supports
- Melos manages multi-package Dart projects with coordinated commands, linking, versioning, changelogs, and publishing
- https://flutter.dev/posts/2015/05/03/introducing-flutter
Supports
- Flutter was introduced publicly in 2015 as an effort to build high-quality interfaces across platforms
- https://flutter.dev/posts/2017/05/17/flutter-alpha
Supports
- Flutter reached alpha in 2017
- https://flutter.dev/posts/2018/12/04/flutter-1-0-googles-portable-ui-toolkit
Supports
- Flutter 1.0 launched in December 2018
- https://flutter.dev/posts/2019/05/07/web
Supports
- Flutter announced a technical preview for web support in 2019
- https://flutter.dev/posts/2021/03/03/whats-new-in-flutter-2
Supports
- Flutter 2 expanded stable support to the web in 2021
- https://flutter.dev/posts/2021/09/08/whats-new-in-flutter-2-5
Supports
- Flutter 2.5 was released in September 2021
- https://flutter.dev/posts/2022/05/11/whats-new-in-flutter-3
Supports
- Flutter 3 added stable support for macOS and Linux desktop in 2022
- https://flutter.dev/posts/2023/01/25/whats-new-in-flutter-3-7
Supports
- Flutter 3.7 improved Material 3 support in 2023
- https://flutter.dev/blog/improving-platform-channel-performance-in-flutter
Supports
- Platform-channel serialization and copying can dominate the cost of large messages
- https://flutter.dev/blog/cross-platform-development-with-flutter-how-google-classroom-gets-teachers-and-students-on-the
Supports
- Google Classroom retained platform-specific details while sharing most of its Flutter interface
- https://flutterflow.io/
Supports
- FlutterFlow provides visual Flutter application development and deployment features
- https://codemagic.io/
Supports
- Codemagic provides CI and delivery automation for Flutter applications
- https://shorebird.dev/
Supports
- Shorebird provides code-push releases for Flutter applications
- https://firebase.google.com/docs/flutter/setup
Supports
- Firebase provides Flutter plugins for adding backend services
- https://docs.sentry.io/platforms/dart/guides/flutter/
Supports
- Sentry provides Flutter error and performance monitoring SDKs
- https://www.revenuecat.com/docs/getting-started/installation/flutter
Supports
- RevenueCat provides a Flutter SDK for in-app purchase management
- https://supabase.com/docs/reference/dart/introduction
Supports
- Supabase provides a Flutter client for backend data, authentication, and storage
- https://appwrite.io/docs/quick-starts/flutter
Supports
- Appwrite provides Flutter SDK support for backend services
