Python has become one of the most popular languages in a variety of fields from scripting, web applications and AI/ML, and now desktop application a soon-to-be conquered or at least as it seems to be.
When it comes to Graphical User Interface (GUI) development, two frameworks have been gaining attention: Flet and Kivy.
But which one should you choose?
Here’s the dilemma:
Both are powerful, yet they shine in different arenas.
Let’s explore each, break down their strengths, and discover which one fits your next project best..
Kivy The OG Python GUI Framework
If Python GUI frameworks were superheroes, Kivy would be the seasoned warrior — reliable, flexible, and everywhere at once.
Kivy is our OG open-source python GUI framework for building and distributing beautiful python cross-platform GUI apps with ease.
Kivy runs on Android, iOS, Linux, macOS and windows, making it one of the few true cross-platform options for Python developers.
I myself have used it to build somewhat personal tools like my own music player, a code editor for mobile phones. it’s suprisingly wild with what you can build with it.
This means with kivy you can develop apps that run on:
- Desktop computers: macOS, Linux, BSD Unix, Windows.
- Android devices: tablets, smart phones
- IOS devices: iPad, iPhone
- Any other touch enabled professional/homebrew devices supporting TUIO (Tangible User Interface Objects)
Kivy is best for apps that require touch support and custom UI
Example of a kivy application
Let’s have a look with a simple application of kivy displaying a button.
from kivy.app import App
from kivy.uix.button import Button
class MyApp(App):
def build(self):
return Button(text="Hello Kivy!", on_press=self.say_hello)
def say_hello(self, instance):
print("Hello User how are you today. Let's build something cool together!")
if __name__ == '__main__':
MyApp().run()
This simple app runs beautifully on desktop and mobile.
But wait, the button is not that beautiful at all. it’s dull. Before you go in the comments and blurst, i have a solution.
Say, you need something more Appy like beautiful modern buttons and other native App elements like Floating Action Buttons, NavBars and Drawers.
This is where Kivy’s stylish sibbling comes in.
KivyMD – Kivy Material Design
Imagine you’re building a mobile app and want it to look clean, modern just like Android apps built with flutter or Kotlin.
That’s exactly what KivyMD does.
KivyMD is a library that extends Kivy with Google’s Material Design components — buttons, dialogs, navigation drawers, app bars, and more.
Think of it as a design upgrade pack that gives your Kivy app that “premium” aesthetic without touching CSS or HTML.
Example of a kivyMD application
Let’s have a look with a simple application of kivy displaying a button.
from kivymd.app import MDApp
from kivymd.uix.button import MDRaisedButton
from kivymd.uix.screen import Screen
class MyApp(MDApp):
def build(self):
screen = Screen()
btn = MDRaisedButton(text="Hello Kivy!", on_release=lambda x: print("Hello User how are you today. Let's build something cool together!"))
screen.add_widget(btn)
return screen
if __name__ == '__main__':
MyApp().run()
Result:
A smooth responsive button with shadows, color effects, and animatios all out of the box.
“With KivyMD, your app stops looking homemade and starts looking professional.”
⚙️ The KV Language — Kivy’s Secret Weapon
Kivy comes with its own markup language — the KV Language — which separates your UI from your app logic.
It’s like HTML and CSS for your Python code.
This makes it easier to manage large projects and keeps your app structure clean.
Example: Counter Application
main.py
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.lang import Builder
from kivy.properties import NumericProperty
class CounterWidget(BoxLayout):
count = NumericProperty(0)
def increase(self):
self.count += 1
def decrease(self):
self.count -= 1
def reset(self):
self.count = 0
class CounterApp(App):
def build(self):
return CounterWidget()
if __name__ == '__main__':
CounterApp().run()
counter.kv
Result
Note:
kivy automatically looks for a .kv file that matches your App class name in lower case, without ‘App’
For example:
If your app class is
class CounterApp(App):
kivy expects the file name to be:
counter.kv
# note that it starts with a small 'c'(referencing your CountApp class) and does not end like counterapp.kv
Make sure it’s exactly
counter.kv, notCounter.kv, notCounterApp.kv
Or if you prefer not to rely on kivy’s auto-detection, you can manual load the .kvfile.
For example:
from kivy.lang import Builder # 👈 add this line
class CounterApp(App):
def build(self):
Builder.load_file("counter.kv") # 👈 and this line
return CounterWidget()
The KV language gives your UI a clear structure and flow – perfect for developers who love visual separation of design and logic.
But what if your goal is to build modern desktop or web app, fast, clean, and Pythonic?
Let’s talk about Flet.
Flet — Flutter-Inspired Python Library.
if Kivy was the veteran, Flet is the cool new prodigy.
Flet is a python framework inspired by Flutter. it lets you build wen, desktop, and mobile applications all usng pure python.
No javascript, No HTML. No Frontend frameworks.
Your entire app is written in python, both frontend and backend.
Example of a simple Flet app
import flet as ft
def main(page: ft.Page):
page.title = "App for Fun"
page.vertical_alignment = page.horizontal_alignment = "center"
page.theme_mode = ft.ThemeMode.LIGHT
def on_click(e):
page.add(ft.Text("Hello, Flet!"))
page.appbar = ft.AppBar(
leading=ft.Icon(ft.Icons.PALETTE),
leading_width=100,
title=ft.Text("Flet", style=ft.TextStyle(
size=16,
color=ft.Colors.BLUE_ACCENT_100,
weight=ft.FontWeight.BOLD
)),
center_title=True,
actions=[
ft.IconButton(
icon=ft.Icons.PERSON,
icon_size=32,
icon_color=ft.Colors.WHITE
),
ft.PopupMenuButton(
items=[
ft.PopupMenuItem("Settings", icon=ft.Icons.SETTINGS),
ft.PopupMenuItem("Privacy", icon=ft.Icons.PRIVACY_TIP, disabled=True),
ft.PopupMenuItem("Exit", icon=ft.Icons.LOGOUT)
],
)
],
bgcolor=ft.Colors.BLUE_100,
)
# add widgets to the page
page.add(
ft.Column(
alignment=ft.MainAxisAlignment.CENTER,
controls=[
ft.ElevatedButton(
"Click Me",
on_click=on_click, style=ft.ButtonStyle(
padding=ft.padding.all(10),
mouse_cursor=ft.MouseCursor.CLICK,
),
width=100,
)
]
)
)
# Run the app
ft.app(target=main)
Run it, and voilà — you have a clean, modern UI that works in your browser or as a local desktop app.
Flet’s syntax feels like React or Flutter, but entirely Pythonic — declarative, simple, and elegant.
Flet is perfect for developers who love Python but want the beauty and responsiveness of web apps.
⚖️ Flet vs Kivy — Head-to-Head Comparison
| Feature | Kivy | Flet |
|---|---|---|
| Platforms | Desktop + Mobile | Desktop + Web (mobile via web) |
| UI Style | Custom, touch-friendly | Declarative, web-style |
| Learning Curve | Moderate | Very easy |
| Best For | Games, multimedia, mobile apps | Dashboards, tools, web apps |
| Community | Mature, large | Growing rapidly |
| Performance | Great for graphics | Great for UI-based apps |
| Design System | KivyMD (Material Add-on) | Built-in Material UI |
| Packaging | Supports Android/iOS builds | Focused on web and desktop |
| Development Speed | Moderate | Very fast |
🧠 Conclusion
So which one should you choose — Kivy or Flet?
At the end of the day it depends on your goal.
- 🖥️ Use Flet if you want to build modern desktop or web apps fast, without touching frontend frameworks.
- 📱 Use Kivy (or KivyMD) if you’re targeting Android/iOS, need touch support, or want to create custom graphics-heavy apps.
Both framworks are powerful, and Python-first.
The real question is:
“Do you want a cross-platform powerhouse or a sleek Python-first UI toolkit?”
Whatever your answer, Python’s GUI scene has never looked more exciting. 🚀
Thanks for reading🙃 C’ya
