Skip to main content

Glossary

A glossary reference for terminology used across docs.flutter.dev.

The following are definitions of terms used across the Flutter documentation.

Adaptive

A design concept where the UI adapts to be usable in the available space, often changing layout or input methods based on device capabilities.

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.

Agent skill

A specialized capability or tool that an AI agent uses for a specific task.

An agent skill is a specialized set of instructions, scripts, and resources that extend an AI agent's capabilities for a specific domain or task. Skills enable agents to interact with the environment, execute multi-step workflows, and perform complex problem-solving autonomously.

Cupertino

Flutter's implementation of the iOS design language.

Flutter's cupertino_ui 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, has been decoupled into a separate package, cupertino_ui on pub.dev.

Dart

A programming language for fast apps on any platform.

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.

Related docs and resources

Declarative

A programming style where the UI state is described, and the framework transitions the UI to match that state.

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.

Embedder

The platform-specific component that supports Flutter on a native platform.

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.

Engine

The portable runtime for Flutter apps.

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.

Frame

A single image in a sequence of images that makes up an animation or UI update.

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.

Related docs and resources

Hot reload

A Flutter feature that allows you to inject updated code into a running application in the Dart VM and see the changes immediately while maintaining application state.

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

Similar to hot reload, but it does not maintain app state. Use hot restart to re-run main or initState .

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

Flutter's modern graphics rendering engine, designed for smooth, predictable performance.

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

When an app appears to stutter or jerk visually instead of animating smoothly.

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

An open-source design system built and supported by Google.

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

The Material library, originally part of the main Flutter repo, has been decoupled into a separate package, material_ui on pub.dev.

Null safety

A Dart feature that prevents errors that result from accessing variables set to null.

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.

Package

At a minimum, a Dart package is a directory containing a pubspec.yaml file.

Additionally, a package can contain dependencies (listed in the pubspec), Dart libraries, apps, resources, tests, images, fonts, and examples. The pub.dev site lists many packages—developed by Google engineers and generous members of the Flutter and Dart community—that you can use in your app.

Plugin

A plugin package (generally referred to as a plugin ), is a special kind of package that makes platform functionallity available to the app.

Plugin packages can be written for Android (using Kotlin or Java), iOS (using Swift or Objective-C), web, macOS, Windows, Linux, or any combination thereof. For example, a plugin might provide Flutter apps with the ability to use a device's camera.

Related docs and resources

Prop drilling

The process of passing data through multiple layers of widgets through constructor parameters.

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.

Related docs and resources

pub

The package manager for the Dart programming language.

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.

Related docs and resources

RenderObject

A persistent object in the Flutter framework responsible for layout, painting, and hit testing.

While widgets are immutable blueprints, RenderObjects are mutable objects that persist between frames. They handle the heavy lifting of determining exactly where elements should be placed and how they should look.

They represent a node in the render tree, which is the most detailed tree in Flutter's multi-tree architecture.

Sliver

A customizable portion of a scrollable area.

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.

Viewport

A widget that displays a subset of its children based on the current scroll offset.

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.

Related docs and resources

Widget

The basic building block of a Flutter user interface.

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.