Glossary

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 Impeller and Skia).
3. Responsible for launching and managing Dart's runtime.
4. Responsible for laying out text.
5. Responsible for asset resolution.

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.

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.

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.

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