ttkbootstrap GUI builder

Design themed ttkbootstrap interfaces in your browser and export runnable Python. Free, no install, and no account needed to start.

ttkbootstrap gives tkinter a modern look by re-theming ttk (the themed widget set already in the standard library) with a set of Bootstrap-inspired palettes. Because the widgets are still ttk widgets, your app stays ordinary Python you run with python main.py. What it doesn't come with is a visual designer, so laying out a window still means guessing coordinates and re-running your script.

This is a free online builder for exactly that. Drag widgets onto a canvas that draws them the way ttkbootstrap actually renders them (flat, square-cornered, accent-driven), set their properties, and download a clean, class-based main.py that imports ttkbootstrap and nothing else of ours. There's no runtime to bundle and no lock-in, and the code is yours.

What the exported code looks like

This is real generated output: standard ttkbootstrap, readable, and yours to edit by hand afterwards:

# Requires ttkbootstrap:  pip install ttkbootstrap
import tkinter as tk
import ttkbootstrap as ttkb


class Application:
    def __init__(self, root):
        self.root = root
        root.title("Login")
        root.geometry("360x240")

        self.label1 = ttkb.Label(root, text="Username")
        self.label1.place(x=40, y=42, width=80, height=26)

        self.entry1 = ttkb.Entry(root)
        self.entry1.place(x=140, y=40, width=170, height=28)

        self.entry2 = ttkb.Entry(root, show="*")
        self.entry2.place(x=140, y=90, width=170, height=28)

        self.button1 = ttkb.Button(root, text="Log in", command=self.on_button1)
        self.button1.place(x=140, y=140, width=100, height=34)

    def on_button1(self):
        username = self.entry1.get()
        self.label1.configure(text="Welcome, " + username + "!")


if __name__ == "__main__":
    root = ttkb.Window(themename="litera")
    app = Application(root)
    root.mainloop()

Which widgets are supported

ttkbootstrap is a skin over ttk rather than a replacement widget set, so the mapping is unusually direct: twenty-one of the twenty-five widgets in the palette become the ttk widget of the same name. Only three have no ttk equivalent at all and fall back to their classic tkinter versions. They work exactly as before, and the canvas shows them that way rather than pretending otherwise.

Colours come from styles, not from options

This is the one thing that catches people out when they move from tkinter to ttk, so the generator handles it for you. A classic tk.Button takes bg= and fg= directly; a ttk button rejects both, because its appearance belongs to a named style. Set a colour on a widget in the inspector and the export defines a style for it:

def styled(name, **options):
    """Define a named ttk style and return its name."""
    ttkb.Style().configure(name, **options)
    return name


self.button1 = ttkb.Button(root, text="Log in", command=self.on_button1,
                           style=styled("button1.TButton",
                                        foreground="#ffffff",
                                        background="#cc3344"))

The styled() helper is only emitted when at least one widget actually needs it, so a design that's happy with the theme exports plain constructors and no boilerplate. Input widgets get fieldbackground rather than background, since on ttk that is the part you type in rather than the trim around it.

Light and dark, decided by you

Pick a project theme and both the canvas and the exported app follow it. The background colour you choose selects the base bootstrap theme. A light background exports Window(themename="litera"), a dark one exports "darkly", and your own colours are then layered over it with ttkb.Style().

Starting from a real bootstrap theme matters, because it supplies everything the designer has no slot for: hover and focus states, dropdown chrome, treeview headings, disabled styling. The three fallback widgets sit outside the ttk style system, so the theme reaches them through tkinter's option database instead, so they follow your colours too.

Switching an existing tkinter project across

The toolkit is a project setting, not a separate editor, so you can cycle between standard tkinter, CustomTkinter and ttkbootstrap whenever you like. Your widgets, layout and handler code are preserved; only the generated code and the canvas appearance change.

Coming from CustomTkinter, two differences are worth knowing. ttk widgets accept both .config() and .configure(), so handler code that CustomTkinter would reject runs fine here. And Progressbar uses ttk's 0–100 range rather than CustomTkinter's 0.0–1.0, so any value you set from your own code needs rescaling.

Running what you export

ttkbootstrap is a third-party package, so install it once:

pip install ttkbootstrap

Then run your app the way you'd run any Python script:

python main.py

Frequently asked questions

Prefer something else?

The same designer exports plain tkinter with no third-party dependency at all (useful on locked-down machines where you can't install packages) and CustomTkinter if you want rounded corners and a fully custom-drawn widget set. Not sure which suits your app? Read CustomTkinter vs ttkbootstrap, which compares them side by side with real generated code. Or see the step-by-step guide, browse the ready-made templates, check the widget reference, or read what to look for when choosing a tkinter GUI builder.