Adaptive

Adaptive design is about the UI beingusable in the space, as opposed to responsive design which is about fitting the UIinto 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.

Cupertino

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

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

Dart

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

Declarative programming is a style where you describe thecurrent 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 callingsetState) and constructs a new widget subtree. This contrasts withimperative programming, where you manually construct and mutate UI entities.

Embedder

Each native platform supported by Flutter has anembedder 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 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 thedart:ui API, which are the low-level primitives that the Flutterframework builds upon.
2. Converts low-level drawing commands into pixels (also calledrasterization, this includesImpellerImpellerFlutter'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

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 seejankJankWhen an app appears to stutter or jerk visually instead of animatingsmoothly.Learn more.

Hot reload

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-runmain orinitState; for that, usehot 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

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

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

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

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

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

Null safety

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

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

Prop drilling

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 (likeInheritedWidget orProvider) are often used.

pub

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 thepubspec.yaml file. Packages are hosted onpub.dev, the official package repository.

Sliver

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 aCustomScrollView 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 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.

Widget

An immutable description of part of a user interface.

In Flutter, almost everything is awidget. 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 areStatelessWidget, which have no mutable state, andStatefulWidget, which have a persistentstate that can be updated.