With Gradio 6.11.0 tab switching completey freezes compared to 6.10.0

[FurkanGozukara]

I noticed this bug at my 2 apps already

CODEX could not fixed this tab freeze no matter what how much I tried

So please analyze 6.11.0 vs 6.10.0 differences at tab render and tab switching there is something broken so bad

Windows 11, Python 3.10.11

Thank you so much

[freddyaboulton]

Hi @FurkanGozukara ! Can you please share the minimal reproducers? Tabs are working well from what we can tell so we need more information to fix your issue.

[Josef-Haupt]

I have the same experience after updating to 6.11
Svelte throws effect_update_depth_exceeded indefinitly after clickling on any tab.
It's hard to produce a minimal example, because there seems to be some interplay, which I've not been able to narrow down, since our app is complex.

[FurkanGozukara]

I have the same experience after updating to 6.11 Svelte throws effect_update_depth_exceeded indefinitly after clickling on any tab. It's hard to produce a minimal example, because there seems to be some interplay, which I've not been able to narrow down, since our app is complex.

Exactly same issue it indefinitely freezes

[Josef-Haupt]

Okay, I've tried to narrow it down to a min example, but this seems to be a bug connected to some complexity inside the tab. So I'm not sure what a minimal example would look like, but I can provide a script that definitly triggers the bug on my end (700 LOC though), would that be helpful? @freddyaboulton

[freddyaboulton]

Yea that would be good thanks @Josef-Haupt !

[Josef-Haupt]

The problem is, that I cannot produce a script that captures the original problem I found in our app

Bildschirmaufnahme.2026-04-09.153127.mp4

[Josef-Haupt]

The only thing I could reliably trigger was this (fast-forward for maximum call stack size exceeded)

Bildschirmaufnahme.2026-04-09.151412.mp4

This issue can be triggered by quickly switching between tabs.
Although I'm sure it's not the same bug, this is the script:

import gradio as gr
import plotly.express as px


def plot_map_scatter_mapbox(lat, lon, zoom=4):
    fig = px.scatter_map(
        lat=[lat], lon=[lon], zoom=zoom, map_style="open-street-map", size=[10]
    )
    fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
    return fig


def build_species_tab():
    with gr.Tab("Foo") as species_tab:
        output_directory_state = gr.State()
        select_directory_btn = gr.Button("Select output directory")
        classifier_name = gr.Textbox("species_list.txt", visible=False, info="info")

        def select_directory_and_update_tb(name_tb):
            return "foo", gr.Textbox(label="foo", visible=True, value=name_tb)

        select_directory_btn.click(
            select_directory_and_update_tb,
            inputs=classifier_name,
            outputs=[output_directory_state, classifier_name],
            show_progress="hidden",
        )

        with gr.Row(equal_height=True):
            with gr.Column(scale=1), gr.Group():
                lat_number = gr.Slider(
                    minimum=-90, maximum=90, value=0, step=1, label="label", info="info"
                )
                lon_number = gr.Slider(
                    minimum=-180, maximum=180, value=0, step=1, label="label", info="info"
                )

            map_plot = gr.Plot(
                plot_map_scatter_mapbox(0, 0), show_label=False, scale=2, visible=True
            )

        lat_number.change(
            plot_map_scatter_mapbox,
            inputs=[lat_number, lon_number],
            outputs=map_plot,
            show_progress="hidden",
        )
        lon_number.change(
            plot_map_scatter_mapbox,
            inputs=[lat_number, lon_number],
            outputs=map_plot,
            show_progress="hidden",
        )

        with gr.Group():
            with gr.Row():
                yearlong_checkbox = gr.Checkbox(True, label="label")
                week_number = gr.Slider(
                    minimum=1,
                    maximum=48,
                    value=1,
                    step=1,
                    interactive=False,
                    label="label",
                    info="info",
                )

            sf_thresh_number = gr.Slider(
                minimum=0.01, maximum=0.99, value=0.03, step=0.01, label="label", info="info"
            )

        def on_change(use_yearlong):
            return gr.Slider(interactive=(not use_yearlong))

        yearlong_checkbox.change(
            on_change, inputs=yearlong_checkbox, outputs=week_number, show_progress="hidden"
        )

        local = gr.Dropdown(
            ["en-US", "de-DE", "fr-FR", "es-ES", "it-IT", "pt-PT", "zh-CN"],
            value="en-US",
            label="label",
            info="info",
        )

        start_btn = gr.Button("label", variant="huggingface")
        start_btn.click(
            print,
            inputs=[
                output_directory_state,
                classifier_name,
                lat_number,
                lon_number,
                week_number,
                yearlong_checkbox,
                sf_thresh_number,
                local,
            ],
        )

    species_tab.select(
        lambda lat, lon: plot_map_scatter_mapbox(lat, lon, zoom=3),
        inputs=[lat_number, lon_number],
        outputs=map_plot,
    )

    return lat_number, lon_number, map_plot


def build_evaluation_tab():
    localized_column_labels = {
        "Start Time": "Start Time",
        "End Time": "End Time",
        "Class": "Class",
        "Recording": "Recording",
        "Duration": "Duration",
        "Confidence": "Confidence",
    }

    def update_selections(*args):
        pass

    with gr.Tab("Eval"):
        gr.Markdown(
            """
            <style>
            .custom-checkbox-group {
                display: grid;
                grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
                grid-gap: 8px;
            }
            </style>
            """
        )

        processor_state = gr.State()
        pa_state = gr.State()
        predictions_state = gr.State()
        labels_state = gr.State()
        annotation_files_state = gr.State()
        prediction_files_state = gr.State()
        plot_name_state = gr.State()

        def get_selection_func(state_key, on_select):
            def select_directory_on_empty():
                return ["", [[""]]]

            return select_directory_on_empty

        with gr.Row():
            with gr.Column():
                annotation_select_directory_btn = gr.Button("label")
                annotation_directory_input = gr.Matrix(
                    interactive=False, headers=["header"]
                )

            with gr.Column():
                prediction_select_directory_btn = gr.Button("label")
                prediction_directory_input = gr.Matrix(
                    interactive=False, headers=["header"]
                )

        with (
            gr.Group(visible=False) as annotation_group,
            gr.Accordion("accordion", open=True),
            gr.Row(),
        ):
            annotation_columns: dict[str, gr.Dropdown] = {}

            for col in ["Start Time", "End Time", "Class", "Recording", "Duration"]:
                annotation_columns[col] = gr.Dropdown(
                    choices=[], label=localized_column_labels[col]
                )

        with (
            gr.Group(visible=False) as prediction_group,
            gr.Accordion("accordion", open=True),
            gr.Row(),
        ):
            prediction_columns: dict[str, gr.Dropdown] = {}

            for col in [
                "Start Time",
                "End Time",
                "Class",
                "Confidence",
                "Recording",
                "Duration",
            ]:
                prediction_columns[col] = gr.Dropdown(
                    choices=[], label=localized_column_labels[col]
                )

        with gr.Group(visible=False) as mapping_group:
            with (
                gr.Accordion("accordion", open=False),
                gr.Row(),
            ):
                mapping_file = gr.File(
                    label="label",
                    file_count="single",
                    file_types=[".json"],
                )
                download_mapping_button = gr.DownloadButton(label="label")

            download_mapping_button.click(fn=lambda: None)

        with (
            gr.Group(visible=False) as class_recording_group,
            gr.Accordion("accordion", open=False),
            gr.Row(),
        ):
            with gr.Column():
                select_classes_checkboxgroup = gr.CheckboxGroup(
                    choices=[],
                    value=[],
                    label="label",
                    info="info",
                    interactive=True,
                    elem_classes="custom-checkbox-group",
                    show_select_all=True,
                )

            with gr.Column():
                select_recordings_checkboxgroup = gr.CheckboxGroup(
                    choices=[],
                    value=[],
                    label="label",
                    info="info",
                    interactive=True,
                    elem_classes="custom-checkbox-group",
                    show_select_all=True,
                )

        with (
            gr.Group(),
            gr.Accordion("accordion", open=False),
            gr.Row(),
        ):
            sample_duration = gr.Number(value=3, label="label", precision=0, info="info")
            recording_duration = gr.Textbox(
                label="label", placeholder="placeholder", info="info"
            )
            min_overlap = gr.Number(value=0.5, label="label", info="info")
            threshold = gr.Slider(
                minimum=0.01, maximum=0.99, value=0.1, label="label", info="info"
            )
            class_wise = gr.Checkbox(label="label", value=False, info="info")

        with (
            gr.Group(),
            gr.Accordion("accordion", open=False),
            gr.Row(),
        ):
            metrics_checkboxes = {}

            for metric_name in [
                "AUROC",
                "Precision",
                "Recall",
                "F1 Score",
                "Average Precision (AP)",
                "Accuracy",
            ]:
                metrics_checkboxes[metric_name.lower()] = gr.Checkbox(
                    label=metric_name, value=True, info=metric_name
                )

        calculate_button = gr.Button("Calculate Metrics", variant="huggingface")

        with gr.Column(visible=False) as action_col:
            with gr.Row():
                plot_metrics_button = gr.Button("Plot Metrics")
                plot_confusion_button = gr.Button("Plot Confusion Matrix")
                plot_metrics_all_thresholds_button = gr.Button(
                    "Plot Metrics for All Thresholds"
                )

            with gr.Row():
                download_results_button = gr.DownloadButton("Download Results")
                download_data_button = gr.DownloadButton("Download Data")

        download_results_button.click(
            fn=lambda pa, predictions, labels, class_wise_value: None,
            inputs=[pa_state, predictions_state, labels_state, class_wise],
        )
        download_data_button.click(fn=lambda processor_state: None, inputs=[processor_state])
        metric_table = gr.Dataframe(
            show_label=False, type="pandas", visible=False, interactive=False
        )

        with gr.Group(visible=False) as plot_group:
            plot_output = gr.Plot(show_label=False)
            plot_output_dl_btn = gr.Button("Download plot", size="sm")

        for comp in (
            list(annotation_columns.values())
            + list(prediction_columns.values())
            + [mapping_file]
        ):
            comp.change(
                fn=update_selections,
                inputs=[
                    annotation_files_state,
                    prediction_files_state,
                    mapping_file,
                    sample_duration,
                    min_overlap,
                    recording_duration,
                    annotation_columns["Start Time"],
                    annotation_columns["End Time"],
                    annotation_columns["Class"],
                    annotation_columns["Recording"],
                    annotation_columns["Duration"],
                    prediction_columns["Start Time"],
                    prediction_columns["End Time"],
                    prediction_columns["Class"],
                    prediction_columns["Confidence"],
                    prediction_columns["Recording"],
                    prediction_columns["Duration"],
                    select_classes_checkboxgroup,
                    select_recordings_checkboxgroup,
                ],
                outputs=[
                    select_classes_checkboxgroup,
                    select_recordings_checkboxgroup,
                    processor_state,
                ],
            )

        def calculate_metrics(*args):
            return (
                gr.update(value="table", visible=True),
                gr.update(visible=True),
                "pa",
                "preds",
                "labs",
                gr.update(),
                gr.update(),
                None,
            )

        calculate_button.click(
            calculate_metrics,
            inputs=[
                mapping_file,
                sample_duration,
                min_overlap,
                recording_duration,
                annotation_columns["Start Time"],
                annotation_columns["End Time"],
                annotation_columns["Class"],
                annotation_columns["Recording"],
                annotation_columns["Duration"],
                prediction_columns["Start Time"],
                prediction_columns["End Time"],
                prediction_columns["Class"],
                prediction_columns["Confidence"],
                prediction_columns["Recording"],
                prediction_columns["Duration"],
                threshold,
                class_wise,
                select_classes_checkboxgroup,
                select_recordings_checkboxgroup,
                processor_state,
                *list(metrics_checkboxes.values()),
            ],
            outputs=[
                metric_table,
                action_col,
                pa_state,
                predictions_state,
                labels_state,
                select_classes_checkboxgroup,
                select_recordings_checkboxgroup,
                processor_state,
            ],
        )

        def plot_metrics(pa, predictions, labels, class_wise_value):
            return gr.update(visible=True), gr.update(value="fig"), "metrics"

        plot_metrics_button.click(
            plot_metrics,
            inputs=[pa_state, predictions_state, labels_state, class_wise],
            outputs=[plot_group, plot_output, plot_name_state],
        )

        def plot_confusion_matrix(pa, predictions, labels):
            return gr.update(visible=True), "fig", "confusion_matrix"

        plot_confusion_button.click(
            plot_confusion_matrix,
            inputs=[pa_state, predictions_state, labels_state],
            outputs=[plot_group, plot_output, plot_name_state],
        )

        annotation_select_directory_btn.click(
            get_selection_func("eval-annotations-dir", lambda: None),
            outputs=[
                annotation_files_state,
                annotation_directory_input,
                annotation_group,
            ]
            + [
                annotation_columns[label]
                for label in [
                    "Start Time",
                    "End Time",
                    "Class",
                    "Recording",
                    "Duration",
                ]
            ],
            show_progress="full",
        )

        prediction_select_directory_btn.click(
            get_selection_func("eval-predictions-dir", lambda: None),
            outputs=[
                prediction_files_state,
                prediction_directory_input,
                prediction_group,
            ]
            + [
                prediction_columns[label]
                for label in [
                    "Start Time",
                    "End Time",
                    "Class",
                    "Confidence",
                    "Recording",
                    "Duration",
                ]
            ],
            show_progress="full",
        )

        def toggle_after_selection(annotation_files, prediction_files):
            return [gr.update(visible=annotation_files and prediction_files)] * 2

        annotation_directory_input.change(
            toggle_after_selection,
            inputs=[annotation_files_state, prediction_files_state],
            outputs=[mapping_group, class_recording_group],
        )

        prediction_directory_input.change(
            toggle_after_selection,
            inputs=[annotation_files_state, prediction_files_state],
            outputs=[mapping_group, class_recording_group],
        )

        def plot_metrics_all_thresholds(pa, predictions, labels, class_wise_value):
            return (
                gr.update(visible=True),
                gr.update(value="fig"),
                "metrics_all_thresholds",
            )

        plot_metrics_all_thresholds_button.click(
            plot_metrics_all_thresholds,
            inputs=[pa_state, predictions_state, labels_state, class_wise],
            outputs=[plot_group, plot_output, plot_name_state],
        )

        plot_output_dl_btn.click(
            lambda plot_output, plot_name_state: print(plot_output, plot_name_state),
            inputs=[plot_output, plot_name_state],
        )


with gr.Blocks() as demo:
    build_species_tab()
    build_species_tab()
    build_evaluation_tab()
    build_evaluation_tab()
    build_evaluation_tab()

demo.launch()

[Josef-Haupt]

I'm not to sure what changed from 6.10 to 6.11 that could cause this, but since you also updated svelte, I'm thinking that maybe there were some breaking changes in Svelte 5.

[freddyaboulton]

Can you please install with the wheel in PR #13240?

pip install https://huggingface.co/buckets/gradio/pypi-previews/resolve/30a3fcf0423e83985a7606db1f043c77add4ca23/gradio-6.11.0-py3-none-any.whl