How to use two different TTK themes in one Tkinter root window?

The ttk module within Tkinter provides themed widgets that enhance the visual aesthetics of your application. While Tkinter allows you to apply a global theme for your entire application using ttk.Style, using multiple themes within the same Tkinter root window can be a bit tricky. This tutorial explores a workaround to achieve this by applying different themes to different frames within the main window.

Understanding Tkinter Themes

In Tkinter, the ttk.Style class is responsible for managing styles and themes. The theme_use() method is used to set the theme for the entire application. However, when you set the theme using ttk.Style, it applies the theme globally to all widgets using that style.

The challenge arises when you want to use two different themes for different parts of your application. Due to the global nature of theme application in Tkinter, applying a theme to one widget affects all widgets using that style throughout the application. To overcome this limitation, we need to be creative in our approach.

Workaround: Multiple Frames with Different Themes

One workaround is to create multiple frames within the main window, each serving as a container for different themed widgets. By creating separate ttk.Style objects and applying themes to individual frames, we can simulate the appearance of using multiple themes in a single Tkinter application.

Implementation Example

Let's create a Tkinter application with two tabs, each having its own theme. We'll use the ttk.Notebook widget to implement the tabbed interface ?

import tkinter as tk
from tkinter import ttk

# Function to set the theme for a specific style
def set_theme(theme_name, style):
    style.theme_use(theme_name)

# Function to create a tab with a specified theme
def create_tab(notebook, theme, tab_text):
    # Create a frame for the tab and add it to the notebook
    tab_frame = ttk.Frame(notebook)
    notebook.add(tab_frame, text=tab_text)
    
    # Create and set theme for the tab frame
    style = ttk.Style(tab_frame)
    set_theme(theme, style)
    
    # Add some sample widgets to the tab frame
    ttk.Label(tab_frame, text="This is the {} tab".format(tab_text)).pack(pady=10)
    ttk.Button(tab_frame, text="Button").pack(pady=10)
    ttk.Entry(tab_frame).pack(pady=10)

# Create the main Tkinter window
root = tk.Tk()
root.title("Multiple Themes Example")
root.geometry("720x250")

# Create a Notebook (Tabbed Interface)
notebook = ttk.Notebook(root)
notebook.pack(padx=10, pady=10)

# Create and set theme for the first tab
create_tab(notebook, "clam", "Tab 1")

# Create and set theme for the second tab
create_tab(notebook, "winnative", "Tab 2")

# Start the Tkinter event loop
root.mainloop()

The output of the above code shows two tabs with different themes ?

A tabbed interface window opens with:
- Tab 1: Using "clam" theme with modern styling
- Tab 2: Using "winnative" theme with native OS styling
Each tab contains a label, button, and entry widget styled according to its respective theme.

How It Works

In this example, we create a Tkinter application with a ttk.Notebook widget containing two tabs. Each tab has its own frame where we set a different theme using a separate ttk.Style object. The create_tab() function handles creating a tab, setting its theme, and adding sample widgets.

Alternative Approach: Custom Styling

Another approach is to create custom styles with different configurations rather than switching entire themes ?

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Custom Styles Example")
root.geometry("400x200")

# Create a single style object
style = ttk.Style()

# Configure custom styles for different sections
style.configure("Blue.TLabel", foreground="blue", font=("Arial", 12))
style.configure("Red.TButton", foreground="red", background="lightgray")

# Create frames for different sections
frame1 = ttk.Frame(root)
frame1.pack(side="left", padx=20, pady=20)

frame2 = ttk.Frame(root)
frame2.pack(side="right", padx=20, pady=20)

# Add widgets with custom styles
ttk.Label(frame1, text="Blue Section", style="Blue.TLabel").pack(pady=5)
ttk.Button(frame1, text="Normal Button").pack(pady=5)

ttk.Label(frame2, text="Red Section").pack(pady=5)
ttk.Button(frame2, text="Red Button", style="Red.TButton").pack(pady=5)

root.mainloop()

The output shows two sections with different custom styling applied to specific widgets ?

A window with two side-by-side sections:
- Left section: Blue label with custom font and normal button
- Right section: Normal label and red-styled button

Key Limitations

• Global Theme State TTK themes are globally applied, so true isolation is limited

• Platform Dependencies Some themes like "winnative" are platform-specific

• Style Conflicts Multiple ttk.Style objects may interfere with each other

Best Practices

• Test your application on different platforms to ensure theme compatibility

• Consider using custom styles instead of multiple themes for better control

• Keep theme switching minimal to maintain consistent user experience

Conclusion

While Tkinter doesn't natively support multiple themes in one window, you can achieve different styling using separate frames with individual ttk.Style objects or custom style configurations. The custom styling approach often provides better control and fewer conflicts than attempting to use multiple complete themes.