Glossary

Adaptive design is about the UI being usable in the space, as opposed to responsive design which is about fitting the UI into the space. An adaptive app selects the appropriate layout (such as having a bottom nav instead of a side panel) and input devices (for example, mouse versus touch) to feel natural on the current device.

Flutter's cupertino library implements the iOS design language, comprising a set of widgets that implement Apple's Human Interface Guidelines.

The cupertino library, originally part of the main Flutter repo, will be decoupled into a separate package. For more information, visit flutter.dev/go/decouple-design.

Dart is an approachable, portable, and performant language designed for full-stack app development. It offers sound null safety, a strong type system, and compiles to native machine code for mobile, desktop, and backend, as well as JavaScript or WebAssembly for the web. While Dart is the foundation of Flutter, it is also used for building command-line tools, servers, and other applications.

Declarative programming is a style where you describe the current state of your UI, and the framework takes care of transitioning the UI to match that state.

In Flutter, widgets are immutable "blueprints". To change the UI, a widget triggers a rebuild on itself (usually by calling setState) and constructs a new widget subtree. This contrasts with imperative programming, where you manually construct and mutate UI entities.

Each native platform supported by Flutter has an embedder for platform-specific logic. The embedder is the bridge that coordinates with the underlying operating system. It provides access to services like input, accessibility, message event loops, and more. The embedder also launches and manages the Flutter engine.

Each embedder is written in the platform's native language: Java and Kotlin for Android, Swift and Objective-C for iOS and macOS, and C++ for Windows and Linux.

Each embedder enables plugin packages to add additional platform-specific functionality to the app.

The embedder is launched and managed by the runner app.

The engine is Flutter's platform-agnostic logic that's written in native code, mostly C++.

The main responsibilities of the engine are as follows:

1. Exposes the dart:ui API, which are the low-level primitives that the Flutter framework builds upon.
2. Converts low-level drawing commands into pixels (also called rasterization, this includes ImpellerImpellerFlutter's modern graphics rendering engine, designed for smooth, predictable performance. Learn more and Skia).
3. Responsible for launching and managing Dart's runtime.
4. Responsible for laying out text.
5. Responsible for asset resolution.

Flutter aims to produce 60 frames per second (fps), or 120 fps on capable devices. This means the framework has approximately 16ms (at 60 fps) or 8ms (at 120 fps) to render each frame. If the app takes longer than this to render a frame, the user might see jankJankWhen an app appears to stutter or jerk visually instead of animating smoothly. Learn more.

This feature is also called "stateful hot reload". After the Dart runtime updates classes with the new versions of fields and functions, the Flutter framework automatically rebuilds the widget tree, allowing you to quickly view the effects of your changes. Hot reload greatly increases the speed of development.

Hot reload works on mobile, web, and desktop apps that are running in debug mode and is fully supported in VS Code, Android Studio, and IntelliJ IDEA. It does not re-run main or initState; for that, use hot restartHot restartSimilar to hot reload, but it does not maintain app state. Use hot restart to re-run `main` or `initState`. Learn more.

Hot restart is still faster than a full restart, which also recompiles the native, platform code (such as Swift). On the web, it also restarts the Dart Development Compiler (DDC).

Impeller is Flutter's high-performance rendering engine, built from the ground up for Flutter's needs and modern graphics APIs.

Its primary goal is to provide consistently smooth performance and eliminate stuttering while rendering, particularly that caused by shader compilation during animations and interactions.

Impeller achieves this by pre-compiling a specific, smaller set of shaders at application build time, rather than compiling at runtime.

Jank occurs when a system can't keep up with the expected frame rate and drops frames. Jank is a performance problem. Flutter offers information and tooling, such as the Performance tool in DevTools, that can help you diagnose and fix jank in your application.

Material Design is an adaptable system of guidelines, components, and tools that support the best practices of user interface design. Flutter's material library implements Material Design widgets.

The material library, originally part of the main Flutter repo, will be decoupled into a separate package. For more information, visit flutter.dev/go/decouple-design.

Dart's null safety prevents errors that result from unintentional access of variables set to null.

With sound null safety, variables are non-nullable by default: they can only be assigned a value of null if you explicitly declare them as nullable. This differs from other "mixed" null safety implementations, where a non-nullable variable could still contain null at runtime. With Dart's sound null safety, the compiler guarantees that a non-nullable variable can never be null.

The process of passing data through multiple layers of widgets through constructor parameters, usually to reach a deeper descendant. This pattern can become verbose, which is why other state management solutions (like InheritedWidget or Provider) are often used.

Pub is the tool used for managing Dart packages. It allows you to install, upgrade, and manage dependencies for your Dart app. Dependencies are defined in the pubspec.yaml file. Packages are hosted on pub.dev, the official package repository.

A sliver is a portion of a scrollable area that you can define to behave in a special way. Think of slivers as building blocks that you can compose together inside a CustomScrollView to create custom scrolling experiences, like elastic scrolling or a collapsing header. Slivers are built lazily, which means that Flutter only renders the slivers that are visible on screen, making them very efficient for long lists of content.

A viewport is the visual component of the scrolling machinery. It displays a subset of its children (usually slivers) based on the current scroll offset. It is often described as being "bigger on the inside" because it can contain more content than is visible on the screen.

An immutable description of part of a user interface.

In Flutter, almost everything is a widget. Widgets are the fundamental building blocks you use to create your application's UI with Flutter. Each widget is an immutable declaration of _what the UI should look like based on its current configuration and state.

Widgets are composed together in a hierarchy to form the widget tree. When a widget's state changes, the Flutter framework rebuilds the necessary parts of the tree to update the UI.

The two primary types of widgets are StatelessWidget, which have no mutable state, and StatefulWidget, which have a persistent state that can be updated.