Adaptive

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.

Cupertino

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

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

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

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.

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

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

Null safety

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.

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 (like InheritedWidget or Provider) 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 the pubspec.yaml file. Packages are hosted on pub.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 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 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.