
Flet 1.0: Building One Python Codebase That Runs on iOS, Android, Desktop, and Web
Flet hit 1.0 in September 2026, and it isn't a version bump with a few new widgets bolted on. The maintainers rewrote the framework from the ground up: the way Python talks to the Flutter renderer changed, the way controls are defined changed, and the amount of boilerplate you write to keep the UI in sync with your state dropped close to zero. If you tried Flet a year or two ago, wrote it off as "neat demo, not production," or you're just hearing about it now because it lets you ship one Python codebase to iOS, Android, Windows, macOS, Linux, and the browser — this is the version worth a second look.
The transport layer got rebuilt, not just optimized
Flet has always worked the same way at a high level: you write Python, Flet renders a real Flutter UI, and the two sides talk over a protocol so your Python process can tell the Flutter side what to draw and get events back. In the 0.x line, that conversation ran over a JSON-based message protocol, with binary data like images and files pushed through as base64 text — which is exactly as wasteful as it sounds for anything with real payloads.
Two things changed by the time 1.0 shipped:
- The socket-based transport between Python and the Flutter side was replaced by an in-process bridge, a change that landed in the 0.86 line as the last big piece of technical debt before 1.0.
- The wire format itself moved from JSON to MessagePack, a binary protocol. Binary assets (images, files) travel as actual bytes instead of base64-inflated text, and the Dart-side control tree now mirrors the Python control tree directly, with matching property names on both sides — which makes debugging a layout issue a lot less like guessing.
None of that is visible in your application code. What you notice is that redraws and event round-trips feel snappier, especially on web and on anything pushing images or file data through the UI.
Controls are plain Python dataclasses now
This is the change that actually touches your code. In 0.x, a control was a class instance you configured with keyword arguments, and Flet handled the JSON serialization behind the scenes in ways that weren't always obvious when something went wrong. In 1.0, controls are dataclasses: you get real constructors, typed fields, default values, validation, and support for nested types and enums for free, courtesy of Python's own dataclass machinery instead of a custom serialization layer.
The practical effect is that your editor's autocomplete and type checker actually know what a Button or a TextField accepts, and a typo in a property name fails immediately instead of silently doing nothing.
You can stop sprinkling .update() everywhere
If you've written Flet 0.x code, you know the rhythm: mutate a control's property, then remember to call page.update() (or the control's own .update()) or nothing changes on screen. Forgetting it was the single most common "why isn't my UI updating" bug reported against the framework.
In 1.0, Flet calls page.update() automatically at the end of every event handler and at the end of main() itself. If your handler still calls .update() explicitly — say, because you ported it from 0.x — Flet detects that and skips the automatic call so you don't pay for a redundant render. You can opt back into fully manual control with ft.context.disable_auto_update() if you have a reason to batch updates yourself, but the default now does the right thing without being asked.
A complete worked example
Here's a small but real app — a Celsius-to-Fahrenheit converter — written against the 1.0 API. Notice there's no page.update() or result.update() anywhere; the UI just reflects whatever you set result.value to:
import flet as ft
def main(page: ft.Page):
page.title = "Unit Converter"
page.padding = 24
page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
celsius = ft.TextField(
label="Celsius",
width=220,
keyboard_type=ft.KeyboardType.NUMBER,
)
result = ft.Text(size=20, weight=ft.FontWeight.BOLD)
def convert(e):
try:
c = float(celsius.value)
except (TypeError, ValueError):
result.value = "Enter a valid number"
result.color = ft.Colors.RED_400
return
f = c * 9 / 5 + 32
result.value = f"{c:.1f}°C = {f:.1f}°F"
result.color = ft.Colors.GREEN_700
page.add(
ft.Column(
[
celsius,
ft.Button("Convert", on_click=convert),
result,
],
horizontal_alignment=ft.CrossAxisAlignment.CENTER,
spacing=16,
)
)
ft.run(main)Two details worth flagging if you're coming from 0.x: it's ft.Button, not ft.ElevatedButton — the old name is gone, not just deprecated — and the color constants are now underscored (ft.Colors.GREEN_700, not a bare attribute lookup that happened to work). Run this with flet run converter.py and you get a desktop window; the exact same file, unmodified, is also what you hand to flet build for every other target.
Shipping the same file to six platforms
This is the actual pitch for Flet, and 1.0 doesn't change the workflow, just makes the build more predictable. Your dependencies live in pyproject.toml, pinned against the 1.0 line:
[project]
dependencies = [
"flet>=1.0.0",
]And then it's one command per target, no code changes between them:
flet build web # browser, WebAssembly + CanvasKit fallback by default
flet build apk # Android
flet build ipa # iOS
flet build macos
flet build windows
flet build linuxFor the web build specifically, 1.0 ships WebAssembly (SKWASM) as the default rendering target on browsers that support it, with the Dart2JS/CanvasKit path kept as a fallback. If you need the app to work with zero external CDN dependency — common for internal tools behind a firewall — pass --no-cdn to flet build web, or set ft.run(main, no_cdn=True) in code; either one bundles CanvasKit, SKWASM, Pyodide, and fonts straight into the app instead of fetching them at runtime.
Migrating from 0.28: this is not a drop-in upgrade
The official migration guide is explicit that 1.0 will break a 0.28 app, and the recommended path is to first run your app on the last 0.86.x release and fix every DeprecationWarning it prints — those warnings are a checklist of exactly what 1.0 removes. The renames that catch the most existing code:
ElevatedButton→Button, andConstrainedControl→LayoutControlapp()/app_async()→run()/run_async(), and thetargetkeyword argument is nowmainPage.go()→Page.push_route()Colors.BLACK12-style names → underscored,Colors.BLACK_12page.clipboard,page.shared_preferences, andpage.storage_pathsmove out to their ownClipboard(),SharedPreferences(), andStoragePaths()controls- the
--clear-cacheflag is gone fromflet build/flet debug— use the newflet cleancommand instead
Going forward, the project says it'll deprecate APIs for a few minor releases before removing them, rather than pulling the floor out the way 1.0 did , which should make the next major version considerably less painful than this one.
If you've been waiting for a real, boring, dataclass-and-autocomplete-friendly way to ship a Python GUI to a phone without touching Kivy or a web wrapper, 1.0 is the first version of Flet actually built to be that. Clone the converter above, point flet build at your platform of choice, and see how far one file gets you.

Experienced DevOps Engineer proficient in Python, Docker, Kubernetes, CI/CD, and cloud technologies. Specialized in automating processes and building scalable infrastructure for seamless development and deployment.


