I believe there has been an IDLE issue, which I cannot find, about title bar control, in particular, min/max buttons. I haven't gotten to it yet as other issue are higher priority. From what you say, this would be a helpful new feature. That said, the new feature template says "Major feature proposals should generally be discussed on Discourse before opening a GitHub issue." This is a major new feature for the purpose of that request, and a post there will be seen by more tkinter users. This should be closed in the meanwhile.

If you can implement a prototype just in Python code, it would be good to release it on pypi.org so it can be tested.

Thank you for the response!

I wanted to clarify the core issue I've encountered: when using overrideredirect(True) to remove the native title bar in Tkinter, it indeed removes the default window chrome, but when implementing a custom title bar with minimize, maximize, and close buttons, things start to break down—particularly with minimize. Trying to minimize the window often crashes the app or leads to unexpected behavior.

There are workarounds, but they are quite complex and typically involve diving into platform-specific APIs like Windows’ ctypes or win32gui. Not only are these solutions fragile and error-prone, but they're also tied to Windows only, leaving Linux and macOS out. This undermines Tkinter's goal of being a cross-platform GUI toolkit.

That's why I believe this should be addressed directly within Tkinter itself, not as a third-party module or external workaround. A built-in, cross-platform way to customize or recreate the window frame—while preserving window functionality like minimize/maximize/close—is important for modern UI development. It empowers developers to build polished, branded, and consistent experiences across all platforms without resorting to low-level hacks.

Thanks again for considering this!

'tkinter' == '(tcl/)tk inter(face)' For widgets, the interface is a fairly thin Python class interface wrapping the tk functions. If you look at tkinter.__init__, nearly all widget methods can a function of the tck interpreter object. _tkinter.c has the code for starting and interacting with the appropriate OS version of the tcl interpreter and for conversions between Python object and tcl strings. It seems that you are asking for a new ttk widget in tk itself.

Custom Title Bar Prototype for Tkinter

This is a working prototype demonstrating how to implement a fully custom title bar and window border in Tkinter, replacing the native window frame with custom controls for minimize, maximize, and close.

import tkinter as tk

FireRed = "#CC3300"

class CustomWindow(tk.Tk):
    def __init__(self):
        super().__init__()

        self.overrideredirect(True)
        self.geometry("900x600+100+100")

        border_thickness = 4
        self.border_frame = tk.Frame(self, bg=FireRed)
        self.border_frame.pack(fill="both", expand=True, padx=0, pady=0)

        self.inner_frame = tk.Frame(self.border_frame, bg="white")
        self.inner_frame.pack(padx=border_thickness, pady=border_thickness, fill="both", expand=True)

        # Title bar with buttons at the top
        title_bar_height = 40
        self.title_bar = tk.Frame(self.inner_frame, bg="white", height=title_bar_height)
        self.title_bar.pack(fill="x", side="top")

        # Buttons frame top right with some vertical padding
        self.button_frame = tk.Frame(self.title_bar, bg="white")
        self.button_frame.pack(side="right", padx=10, pady=(8, 8))

        btn_style = dict(width=3, font=("Segoe UI", 14), bd=0, relief="flat", padx=0, pady=0)

        self.min_button = tk.Button(self.button_frame, text="—", command=self.minimize_window, **btn_style)
        self.max_button = tk.Button(self.button_frame, text="□", command=self.maximize_restore_window, **btn_style)
        self.close_button = tk.Button(self.button_frame, text="✕", command=self.close_window, **btn_style)

        self.min_button.pack(side="left", padx=(0, 5))
        self.max_button.pack(side="left", padx=(0, 5))
        self.close_button.pack(side="left")

        # Hover effects
        self.min_button.bind("<Enter>", lambda e: self.min_button.config(bg="yellow"))
        self.min_button.bind("<Leave>", lambda e: self.min_button.config(bg="white"))

        self.max_button.bind("<Enter>", lambda e: self.max_button.config(bg="yellow"))
        self.max_button.bind("<Leave>", lambda e: self.max_button.config(bg="white"))

        self.close_button.bind("<Enter>", lambda e: self.close_button.config(bg="red", fg="white"))
        self.close_button.bind("<Leave>", lambda e: self.close_button.config(bg="white", fg="black"))

        # Drag window by title bar
        self.title_bar.bind("<ButtonPress-1>", self.start_move)
        self.title_bar.bind("<B1-Motion>", self.do_move)

        # CENTER LABEL in window (below title bar)
        self.center_label = tk.Label(self.inner_frame,
                                     text="Custom titlebar prototype",
                                     font=("Segoe UI", 24, "bold"),
                                     bg="white",
                                     fg="black")
        self.center_label.pack(expand=True)

        self.is_maximized = False
        self.normal_geometry = self.geometry()

    def start_move(self, event):
        self.x = event.x
        self.y = event.y

    def do_move(self, event):
        x = event.x_root - self.x
        y = event.y_root - self.y
        self.geometry(f"+{x}+{y}")

    def minimize_window(self):
        self.update_idletasks()
        self.overrideredirect(False)
        self.iconify()
        def restore_override():
            if not self.state() == 'iconic':
                self.overrideredirect(True)
            else:
                self.after(100, restore_override)
        self.after(100, restore_override)

    def maximize_restore_window(self):
        if not self.is_maximized:
            self.normal_geometry = self.geometry()
            self.geometry(f"{self.winfo_screenwidth()}x{self.winfo_screenheight()}+0+0")
            self.is_maximized = True
            self.max_button.config(text="❐")  # Restore icon
        else:
            self.geometry(self.normal_geometry)
            self.is_maximized = False
            self.max_button.config(text="□")

    def close_window(self):
        self.destroy()

if __name__ == "__main__":
    app = CustomWindow()
    app.mainloop()

Code Explanation

• overrideredirect(True) disables the native window frame, allowing a fully custom title bar and border.
• The outer border_frame draws a solid FireRed border (thickness 4 px) around the window.
• The inner frame holds the white background content area.
• The title_bar frame contains the minimize, maximize/restore, and close buttons aligned top-right with some padding.
• Buttons change color on hover: yellow for minimize/maximize, red for close.
• The title bar supports dragging the window by tracking mouse movements.
• Minimizing uses a workaround: disables overrideredirect, calls iconify(), then re-enables overrideredirect after restore to avoid errors on Windows.
• Maximizing toggles between fullscreen and original window size.
• Close button destroys the window.
• A centered label below the title bar shows the window content.

Limitations and Behavior Across Platforms

• Windows:
  Works smoothly with the minimize workaround. The border, custom buttons, drag, and maximize behave as expected.

• Linux/macOS:
  Behavior can vary by window manager and Tkinter/Tk implementation.

  • Minimizing may fail or cause errors due to overrideredirect restrictions.
  • Maximizing and dragging usually work but can be inconsistent.
  • The custom border appearance depends on platform window manager.
    Full consistency would require platform-specific adjustments or external libraries.

Summary

This prototype confirms it’s possible to implement a custom title bar and window frame in pure Tkinter, with native window functions recreated as custom widgets.

However, platform differences and Tkinter limitations mean this is a solid base but not a full replacement for native window frames without further work.

Below is a screenshot showcasing the final prototype in action: