gradio-app/gradio
45.9
Weak · 14 November 2026
187.3k
lines of production code
TypeScript
with Python
6
measurements over time
What this system is
Features
Add AnimeGANv2 face transformation demo
A new interactive demo has been added to the website that allows users to apply AnimeGANv2 style transformations to portrait images. Users can upload a cropped face photo and choose between two model versions: Version 1, which prioritizes stylization, and Version 2, which offers greater robustness. The interface is built using Gradio and loads the underlying PyTorch models directly from the AK391/animegan2-pytorch repository.
demo/animeganv2 · high confidence
Add Bokeh plot demo with map, whisker, and scatter visualizations
A new demo application has been added at demo/bokeh\_plot/run.py that showcases Bokeh plotting capabilities within Gradio. The demo provides a user interface with a radio selector to switch between three distinct visualization types: a Mercator map using OpenStreetMap tiles, a whisker plot displaying car class versus highway MPG with quintile ranges, and a scatter plot comparing penguin flipper length against body mass. This allows users to see how Gradio's gr.Plot component integrates with Bokeh's figure and data source APIs for interactive data exploration.
_demo/bokeh\plot · high confidence
Add Chatbot Demo using DialoGPT and Gradio
A new interactive chatbot demo has been added to the \demo/chatbot\_dialogpt\ directory. This feature allows users to engage in a conversational interface powered by the Microsoft DialoGPT-medium model, utilizing the Gradio library for the UI. Users can type messages to receive AI-generated responses, with the ability to clear the conversation history.
_demo/chatbot\dialogpt · high confidence
Add Color Generator demo application
A new demo application named 'Color Generator' has been added to the \demo/color\_generator\ directory. This Gradio-based interface allows users to generate random light or dark colors by selecting a style via a radio button. Upon submission, the application displays the selected color using a color picker, shows the corresponding hexadecimal value in a text box, and renders a 50x50 pixel image of the generated color.
(repo-wide) · high confidence
Add DataFrame streaming demo with change and input event tracking
The demo/dataframe\_streaming/run.py file has been added to demonstrate gr.DataFrame functionality, specifically illustrating how to handle streaming updates and track change/input events. The demo includes a button to trigger dataframe updates, a number input, and displays for change events, input events, and the sum of values, providing a practical example for users to understand dataframe interactivity and event handling.
_demo/dataframe\streaming · high confidence
Add GPT-2 XL demo applications
New demo scripts have been added for the GPT-2 XL model, providing both a standard Gradio interface and a unified interface variant. Users can now launch these demos to interact with the GPT-2 XL model directly via a web UI, with the unified version offering a specific text-processing wrapper around the model's API.
_demo/gpt2\_xl, demo/gpt2\_xl\unified · high confidence
Add Hugging Face Transformers chat demo
A new demo script has been added to the \llm\_hf\_transformers\ directory that demonstrates a chat interface using the Hugging Face \transformers\ library. The example loads the \SmolLM2-135M-Instruct\ model and tokenizer, allowing users to interact with the model via a Gradio \ChatInterface\ component.
_demo/llm\_hf\transformers · high confidence
Add JSON component demo with NumPy array support
A new demo application for the JSON component has been added, showcasing how the component handles various data types including nested objects, arrays, and primitive values. Notably, the demo includes a NumPy array (np.array) within the JSON structure, demonstrating the component's ability to serialize complex Python objects.
_demo/json\component · high confidence
Add LaTeX rendering demo
A new demo application has been added to the \demo/latex\ directory that showcases Gradio's ability to render LaTeX mathematical expressions within Markdown blocks. The \run.py\ script initializes a Gradio Blocks interface displaying various inline and block-level formulas (such as integrals and fractions) alongside plain text, allowing users to preview how LaTeX content is processed and displayed in the UI.
demo/latex · high confidence
Add MiniMax chatbot demo using M3 model
A new demo application has been added for the MiniMax LLM provider, allowing users to interact with the MiniMax-M3 model via a Gradio ChatInterface. The demo requires the MINIMAX\_API\_KEY environment variable and connects to the MiniMax API endpoint.
_demo/llm\minimax · high confidence
Add PDF text highlighting demo for LLM RAG workflows
A new demo application has been added at \demo/highlight\_pdf\ that demonstrates how to highlight specific text within a PDF file using PyMuPDF and display the result in a Gradio interface. The application allows users to input a query, which triggers a function to search for and annotate matching text instances in a sample PDF, then returns the modified PDF along with the page number where the text was found, facilitating retrieval-augmented generation (RAG) use cases.
_demo/highlight\pdf · high confidence
Add Polars-based record sorting demo
A new demo application has been added to the sort\_records location that demonstrates sorting records using Polars DataFrames. The demo includes a CSV data file (polars\_sort.csv) and a Gradio interface (run.py) that allows users to sort items by quantity, specifically leveraging the Polars backend for dataframe operations.
_demo/sort\records · high confidence
Add Stable Diffusion demo with Gradio UI
A new demo application for Stable Diffusion has been added to the \demo/stable-diffusion\ directory. It provides a Gradio-based interface allowing users to generate images from text prompts, with controls for the number of samples, inference steps, guidance scale, and seed. The implementation includes basic NSFW content filtering and loads the CompVis/stable-diffusion-v1-4 model.
demo/stable-diffusion · high confidence
Add Theme Builder demo with custom CSS support
The theme builder demo now includes a custom CSS file that adjusts the container overflow and styles the controls panel with a sticky header and custom scrollbar. The demo application loads this custom CSS when running in a Gradio Space, while falling back to a different path for local execution, ensuring the visual layout remains consistent across environments.
_demo/theme\builder · high confidence
Add TypeScript definitions for Gradio atoms components
This change introduces TypeScript declaration files (.d.ts) for the core UI components in the \js/atoms\ package, including Block, IconButton, ShareButton, and UploadText. By providing these type definitions, the library now offers improved type safety and developer experience for users integrating Gradio's frontend atoms into TypeScript-based projects.
home/runner/work/gradio/gradio/js/atoms · high confidence
Add audio pitch detection demo
A new demo application has been added at demo/main\_note/run.py that allows users to upload or record audio to detect the dominant musical pitches. The interface uses Gradio to accept audio input, performs FFT-based frequency analysis to identify the most prominent notes, and displays the top four detected pitches as labels.
_demo/main\note · high confidence
Add audio streaming demo with stateful concatenation
A new demo application at demo/stream\_audio/run.py demonstrates real-time audio streaming by concatenating microphone input with previous stream data. Users can record audio via a microphone, which is streamed and appended to the output in real-time using a Gradio State object, and clear the entire stream with a dedicated button.
_demo/stream\audio · high confidence
Add blocks\_layout demo showcasing component layout and sizing
A new demo application has been added at demo/blocks\_layout/run.py that demonstrates various Gradio layout capabilities. The example illustrates the use of Row and Column containers to arrange components, shows how the scale parameter affects component width distribution, and includes examples of fixed-width buttons using min\_width alongside scalable elements.
_demo/blocks\layout · high confidence
Add browser-local run history and loading
Users can now view and replay their previous app runs directly in the browser. This change introduces a new Run History feature that persists run data locally, allowing users to restore previous states and inputs/outputs without needing to re-run the app. The implementation includes new Svelte components (RunHistory, RunValue) and utilities to manage and display these saved runs, enhancing the development and testing workflow by providing immediate access to historical execution data.
js/spa · high confidence
Add button and gallery component demos
New demo scripts have been added for the Button and Gallery components. The Button demo illustrates various styling options including primary/secondary/stop variants, small sizes, icons, and interactive states. The Gallery demo demonstrates how to display a mix of image and video sources using both direct URLs and local file paths.
_demo/gallery\component · high confidence
Add color picker demo for icon recoloring
A new demo application has been added to the color\_picker location that demonstrates the gr.ColorPicker component. Users can upload a PNG icon and select a color to dynamically recolor the icon's non-transparent pixels, with the result displayed as an output image.
_demo/color\picker · high confidence
Add demo for Textbox max\_lines parameter
A new demo file has been added to showcase the \max\_lines\ parameter on a Gradio Textbox component, configuring it to display 2 lines with a maximum of 4 lines.
_demo/blocks\_textbox\_max\lines · high confidence
Add demo for interface with no input
A new demo application has been added that demonstrates a Gradio interface configured with no input fields. The application features a single button that, when clicked, displays a randomly selected greeting message from a predefined list.
_demo/no\input · high confidence
Add demo showcasing Dataframe visibility in background tabs
A new demo script has been added to the dataframe\_tab location that demonstrates rendering a Dataframe component within a background tab. The example ensures that the Dataframe is visible and correctly displayed when the user selects the tab containing it, serving as a reference for handling component visibility in non-active tabs.
_demo/dataframe\tab · high confidence
Add demo showcasing the Soft theme
A new demo application has been added to the theme\_soft location that demonstrates the gr.themes.Soft() theme. The demo includes a text input, a slider, submit and clear buttons, and an output field, allowing users to preview how the Soft theme styles these components.
_demo/theme\soft · high confidence
Add fake GAN demo
A new demo has been added at demo/fake\_gan that demonstrates a text-to-image interface. The demo uses a Gradio Blocks layout with a Gallery component to display generated images and a Textbox for progress status, triggered by a 'Generate images' button. It simulates generation by randomly selecting from a set of external face images and includes a description file linking to the Stable Diffusion demo for further context.
(repo-wide) · high confidence
Add image flipping demo with embedded examples
A new demo application has been added to the examples component that demonstrates image manipulation using Gradio. The app allows users to upload an image and flip it 180 degrees, featuring embedded example images (cheetah1.jpg and lion.jpg) to facilitate immediate testing without manual uploads.
_demo/examples\component · high confidence
Add interactive plot and data demonstration guides
Added a series of new demo applications in the \demo/\ directory that showcase Gradio's plotting and data handling capabilities. These guides demonstrate how to create and interact with \BarPlot\, \LinePlot\, and \ScatterPlot\ components, including features like dynamic binning, datetime range filtering, and multi-input data filtering. The collection also includes examples for displaying data tables with summary statistics.
(repo-wide) · high confidence
Add kitchen sink and longest word demos
New demo applications have been added to the repository: a 'kitchen sink' demo that showcases a wide variety of Gradio components (including textboxes, sliders, images, audio, video, dataframes, and datetime) within a single interface, and a 'longest word' demo that demonstrates a simple text-processing interface.
_demo/kitchen\sink · high confidence
Add kitchen\_sink\_random demo to showcase randomized component states
A new demo application has been added at demo/kitchen\_sink\_random that initializes all Gradio input components with random values on load. The demo includes a wide variety of components—such as Textbox, Number, Slider, Checkbox, Dropdown, Image, Video, Audio, File, Dataframe, State, ColorPicker, Label, HighlightedText, JSON, HTML, Gallery, Chatbot, Model3D, Plot, and Markdown—each configured with lambda functions or random selection logic to demonstrate dynamic initial states.
_demo/kitchen\_sink\random · high confidence
Add live variable demo
A new demo application has been added to the live\_with\_vars directory, demonstrating how to use Gradio's live mode with state variables. The example shows an interface where two textboxes are connected, allowing real-time updates as the user types, illustrating the interaction between input components and state management in a live setting.
_demo/live\_with\vars · high confidence
Add native plot lite demos for bar and line charts
Added new demo applications in \demo/bar\_plot\_demo\ and \demo/line\_plot\_demo\ that showcase the \gr.BarPlot\ and \gr.LinePlot\ components. These demos illustrate interactive features such as time-based grouping, data aggregation, axis rescaling via date pickers, and sorting capabilities.
_demo/bar\_plot\_demo, demo/line\_plot\demo · high confidence
Add simple progress bar demo
A new demo application has been added at demo/progress\_simple/run.py that demonstrates the Gradio Progress component. The example implements a function that reverses a string character by character, using the progress tracker to update the UI with a description and a tqdm-based progress bar to visualize the operation's completion.
_demo/progress\simple · high confidence
Add slider release event support
The demo/slider\_release example now demonstrates the new slider release event, allowing users to trigger actions specifically when a slider interaction is finished rather than during continuous dragging. This enables workflows where updates or calculations are deferred until the user has settled on a final value.
_demo/slider\release · high confidence
Add spectrogram audio analysis demo
A new demo application has been added to the spectogram directory that allows users to upload audio files and visualize their spectrograms. The interface uses Gradio to accept audio input, processes the signal using SciPy to compute the spectrogram, and displays the result as a plot using Matplotlib.
demo/spectogram · high confidence
Add streaming speech recognition demo
Introduces a new interactive demo in the streaming\_wav2vec directory that uses Gradio to provide real-time automatic speech recognition. The application captures audio from a microphone, processes it through a Hugging Face transformers pipeline, and displays the transcribed text in a live-updating interface.
_demo/streaming\wav2vec · high confidence
Add text analysis demo with NER and dependency visualization
A new demo has been added to the text\_analysis location that leverages Gradio's HighlightedText, JSON, and HTML outputs to provide clear Named Entity Recognition (NER) segmentation. The application uses the spaCy library (en\_core\_web\_sm model) to process input text, returning tokenized parts-of-speech, character/token counts, and an interactive HTML dependency tree visualization.
_demo/text\analysis · high confidence
Add tone generation demo
A new demo application has been added at demo/generate\_tone/run.py that allows users to generate audio tones. The interface accepts a musical note (selected from a dropdown), an octave (selected via a slider), and a duration in seconds (entered as text), then produces and returns the corresponding audio file using Gradio.
_demo/generate\tone · high confidence
Add translation demo using NLLB-200
A new translation demo has been added to the demo/translation directory. This demo allows users to input text and select source and target languages (currently supporting Acehnese, English, French, and Spanish) to generate translations using the Facebook NLLB-200-distilled-600M model via the Hugging Face Transformers library.
demo/translation · high confidence
Add unified text generation demo using Gradio and GPT-2
A new demo application has been added at demo/unified\_demo\_text\_generation/run.py that provides a simple web interface for text generation. Users can input a text prompt into a textbox and receive a generated response using the GPT-2 model via the Hugging Face Transformers library, powered by the Gradio framework.
_demo/unified\_demo\_text\generation · high confidence
Add webcam snapshot demo
A new demo application has been added at demo/blocks\_webcam/run.py that allows users to take a snapshot using their webcam. The interface captures an image from the webcam source and applies a vertical flip (upside-down) transformation before displaying the result.
_demo/blocks\webcam · high confidence
Add webcam streaming image demo
A new demo application has been added at demo/stream\_frames/run.py that demonstrates real-time image streaming from a webcam. The example uses Gradio's Interface with a streaming Image input and a simple flip function, enabling users to see live, processed video output directly in the browser.
_demo/stream\frames · high confidence
Added ASR demo applications for batch and streaming speech recognition
New demo applications have been added to the \demo/asr\ and \demo/stream\_asr\ directories, providing users with ready-to-run examples for automatic speech recognition using the \openai/whisper-base.en\ model via Gradio. The \demo/asr/run.py\ script implements a batch transcription interface that accepts audio input from a microphone and returns the full transcript, while \demo/stream\_asr/run.py\ implements a live streaming interface that processes audio chunks in real-time, maintaining state to accumulate the audio stream for continuous transcription.
_demo/asr, demo/stream\asr · high confidence
Added Blocks Hello World demo
A new demo application has been added to the 'blocks\_hello' location, demonstrating a basic Gradio Blocks interface. This example features a text input field where users can enter their name, which triggers a welcome message displayed in an output text box, illustrating the core event-handling capabilities of the Blocks API.
_demo/blocks\hello · high confidence
Added DataFrame interaction demo
A new demo script has been added to the dataframe\_block-ui-test location that demonstrates a Gradio interface with a Slider, a DataFrame, and a Button. Clicking the button updates the DataFrame with generated data based on the slider value, allowing users to test interactive DataFrame behavior.
_demo/dataframe\block-ui-test · high confidence
Added Gradio Blocks demo application
A new demo application has been added to the \demo/hello\_blocks\ directory, demonstrating the use of Gradio Blocks. This example creates a simple interactive interface where users can input a name and click a 'Greet' button to receive a personalized greeting message, showcasing basic component layout and event handling within the Blocks API.
_demo/hello\blocks · high confidence
Added Hangman game demo
A new interactive Hangman game demo has been added to the demo/hangman directory. Users can now play a word-guessing game where they enter letters to reveal a secret word, with the interface tracking used letters and the current state of the word.
demo/hangman · high confidence
Added MCP-only list slicing demo
A new demo application has been added at demo/mcp\_tool\_only/run.py that exposes a list slicing tool via the Model Context Protocol (MCP). The application uses Gradio to define a 'slice\_list' function and registers it as an API endpoint, launching the server in MCP mode to allow external clients to interact with the tool programmatically without a traditional UI.
_demo/mcp\_tool\only · high confidence
Added Markdown demo component
A new demo application has been added at demo/markdown\_example/run.py that showcases the Gradio Markdown component. The example renders a sample document (Dillinger) containing various Markdown elements such as headings, lists, code blocks, and links, allowing users to see how the component handles rich text content.
_demo/markdown\example · high confidence
Added TypeScript definitions for audio and status tracker components
This change introduces TypeScript declaration files (.d.ts) for the audio module and the status tracker UI components. For audio, it defines types for waveform options, subtitle data, and audio component props and events. For the status tracker, it exposes type definitions for the main status index, individual UI components (Loader, Toast, StreamingBar, LiveStatus), the internal state management class (LoadingStatus), and shared types for loading status and toast messages. These additions provide static type checking and IntelliSense support for developers using these Gradio components.
home · high confidence
Added calculator and score tracker demo applications
New demo applications have been added to the repository, including a toy calculator that supports addition, subtraction, multiplication, and division with error handling for division by zero, and a score tracker that maintains a list of scores and displays the top three. These demos provide users with practical examples of how to use Gradio's Interface component for basic arithmetic operations and stateful data tracking.
demo/calculator · high confidence
Added demo app for testing iframe resizing with images
A new demo application has been added to the iframe\_resizer directory to help verify iframe height adjustments. The app includes a tab with multiple images and another tab with accordions and toast notifications, allowing users to test how the iframe resizes when content such as images loads or when UI elements like warnings and errors are triggered.
_demo/iframe\resizer · high confidence
Added demo components for Duplicate and Login buttons
New demo scripts have been added for the DuplicateButton and LoginButton components, providing simple examples of how to instantiate and launch these UI elements using Gradio Blocks.
_demo/duplicatebutton\_component, demo/loginbutton\component · high confidence
Added demo for Gradio behind reverse proxy with custom path
A new demo script at demo/custom\_path/run.py demonstrates how to correctly mount a Gradio app on a custom path when running behind a reverse proxy. It simulates a proxy environment by wrapping the FastAPI application in a Starlette app mounted at /myapp, with Gradio mounted at /gradio, and explicitly sets the root\_path to ensure media assets load correctly in this nested routing scenario.
_demo/custom\path · high confidence
Added demo for Gradio input validation
A new demo application has been added to the validator\_simple directory that demonstrates how to use the \validator\ parameter in Gradio button clicks. The example shows a form with age and location inputs, applying custom validation logic to ensure the age is at least 3 and the location is not London, before processing the text.
_demo/validator\simple · high confidence
Added demo for component visibility toggling
A new demo application has been added at demo/render\_visibility/run.py that demonstrates how to toggle the visibility of Gradio components (Textbox, ImageEditor) using Show and Hide buttons within a tabbed interface.
_demo/render\visibility · high confidence
Added demo for consecutive chatbot interactions
A new demo application has been added to the \demo/chatbot\_consecutive\ directory, demonstrating how to chain events using Gradio's \.then()\ method. This example implements a simple chat interface where a user's message is processed and then, after a short delay, a bot response is appended to the conversation history, illustrating sequential event handling in a chatbot workflow.
_demo/chatbot\consecutive · high confidence
Added demo for hot reload behavior with indirect module references
A new demo application in the \demo/reload\_mode\ directory illustrates how Gradio handles module reloading. The \run.py\ script imports a helper function \get\_status\ from a separate \functions.py\ file, allowing users to observe the difference in behavior between a full restart and a hot reload when indirectly referenced modules are involved.
_demo/reload\mode · high confidence
Added demo for rendering large DataFrames with mixed datetime and text types
A new demo script has been added to the \demo/dataframe\_datetime\_long\ directory to reproduce and test performance issues when rendering a DataFrame with 5,000 rows containing mixed data types, including dates, strings, numbers, booleans, markdown, and HTML.
_demo/dataframe\_datetime\long · high confidence
Added demo for variable number of outputs
A new demo application has been added to the \demo/variable\_outputs\ directory, illustrating how to create interfaces with a variable number of output components. The example uses a slider to dynamically control the visibility of textboxes, providing a practical reference for users implementing similar dynamic UI patterns.
_demo/variable\outputs · high confidence
Added demo scripts for LinePlot and Temporal LinePlot
New demo scripts have been added for the \plot\_guide\_line\ and \plot\_guide\_temporal\ locations. The \plot\_guide\_line\ demo demonstrates a basic line plot using weight and height data, while the \plot\_guide\_temporal\ demo showcases line and scatter plots with time-series data, including price trends and flight origins.
_demo/plot\_guide\_line, demo/plot\_guide\temporal · high confidence
Added demo to test queue full behavior and error handling
A new end-to-end demo has been added at demo/queue\_full\_e2e\_test that demonstrates how the application handles a full request queue and backend exceptions. The demo uses Gradio with a concurrency-limited queue (max\_size=2) and includes logic to simulate a client-side error on the first call, allowing users to verify that queue saturation and exceptions do not break the client or the queue.
_demo/queue\_full\_e2e\test · high confidence
Added interactive todo list demo
A new demo application has been added at demo/todo\_list/run.py that demonstrates a functional todo list interface. Users can input task names via a text box, and the app dynamically renders incomplete tasks with 'Done' and 'Delete' buttons, while also displaying a separate section for completed tasks, all managed through Gradio's state and render components.
_demo/todo\list · high confidence
Added multimodal chat interface demo with file upload examples
A new demo application has been added to the test\_chatinterface\_multimodal\_examples directory, showcasing the gr.ChatInterface component in multimodal mode. This example allows users to send text messages along with uploaded image and audio files, demonstrating how the interface handles mixed content inputs through predefined examples.
_demo/test\_chatinterface\_multimodal\examples · high confidence
Added rapid generation demo with chained streaming events
A new demo application has been added at demo/rapid\_generation/run.py that showcases Gradio's event chaining and streaming capabilities. The interface features a chatbot component and four number inputs, where clicking a button triggers a sequence of ten chained events. These events demonstrate streaming updates by yielding intermediate states for both the chat history and the number inputs, allowing users to observe how multiple dependent events can be linked together in a single interaction.
_demo/rapid\generation · high confidence
Added reverse audio and video identity demo applications
Two new demo applications have been added to the playground: a reverse audio tool that flips audio input from a microphone, and a video identity tool that passes through video input. These demos utilize the Gradio library to provide simple, interactive interfaces for testing audio and video processing capabilities.
_demo/reverse\_audio\_2, demo/video\_identity\2 · high confidence
Added standalone demo scripts for core Gradio components
This change introduces individual, runnable Python scripts for a wide range of core Gradio components—including Checkbox, CheckboxGroup, ColorPicker, Dropdown, File, Image, Label, Model3D, Number, Plot, Radio, Slider, State, and Textbox—located in the \demo/\ directory. Each script provides a minimal, self-contained example demonstrating how to instantiate and launch the respective component using the \gr.Blocks\ API, serving as quick-start references for users.
(repo-wide) · high confidence
Added tabbed interface demo
A new demo application has been added at demo/tabbed\_interface\_lite/run.py that showcases the gr.TabbedInterface component. This example combines three distinct Gradio interfaces—a simple text transformation, a second text transformation, and a chat interface—into a single tabbed layout, providing a concrete reference for users looking to organize multiple apps within one interface.
(repo-wide) · high confidence
Added test execution script for Python client
A new shell script (test.sh) has been added to the client/python/scripts directory to facilitate running the Python client's test suite. This script sets the execution environment using bash, changes the working directory to the parent folder, and invokes pytest to execute the tests.
client/python/scripts · high confidence
Added theme customization demo scripts
New demo scripts have been added to the \demo/\ directory to illustrate how to apply and customize themes in Gradio. These examples demonstrate using built-in theme variants with specific color hues (e.g., red/pink), adjusting layout properties like spacing and radius, and creating custom theme classes by extending \gr.themes.Base\ with configurable parameters for colors, fonts, and sizes.
(repo-wide) · high confidence
Added validator demo applications for Gradio
New demo applications have been added in the \demo/validator\_interface\ and \demo/validator\_test\ directories to showcase the Gradio \validator\ parameter. These demos illustrate how to implement input validation for text fields (checking age and location constraints) and image uploads (enforcing portrait orientation), as well as how validation errors are handled and displayed to users.
_demo/validator\_interface, demo/validator\test · high confidence
Added web component embed demo application
A new demo application has been added to the \demo/web\_component\_embed\ directory, providing a simple Gradio interface with a text input and a greeting button. This demo serves as a target for embedding Gradio as a web component, addressing the \this.app.$destroy is not a function\ error previously encountered in this context.
(repo-wide) · medium confidence
Centralized demo runner with error handling
A new entry point (demo/all\_demos/run.py) dynamically loads and mounts individual demo applications from the demos directory into a single Gradio app, allowing users to navigate between demos via URL routes. The implementation includes robust error handling: if a specific demo fails to load (e.g., due to timeouts or import errors), the app gracefully displays an error message for that demo instead of crashing the entire application.
_demo/all\demos · high confidence
ChatInterface now supports additional outputs for side-panel content
The demo at demo/chatinterface\_artifacts demonstrates that gr.ChatInterface now accepts an additional\_outputs argument, allowing the chat component to emit extra UI elements (such as a gr.Code block) alongside the standard chat response. This enables users to display supplementary content, like code artifacts, in a separate panel while interacting with the chat.
_demo/chatinterface\artifacts · high confidence
Chatbot demo now supports streaming Gradio components and file attachments
The chatbot demo has been updated to demonstrate sending complex Gradio components (such as plots, galleries, dataframes, images, videos, and audio) directly as bot responses, rather than just text. It also now supports receiving file attachments (images, audio, video, text) from users via the multimodal input box, allowing the chat history to include these media files alongside text messages.
_demo/chatbot\_core\components · high confidence
Deep link support in demo applications
The deep\_link demo now includes a DeepLinkButton component, allowing users to generate and share direct links to the current state of the chat interface.
_demo/deep\link · high confidence
Demo added for Dropdown key\_up event
A new demo application has been added to showcase the \key\_up\ event on the \gr.Dropdown\ component. The example demonstrates how to capture key press data, including the specific key and input value, and display it in a JSON output block.
_demo/dropdown\_key\up · high confidence
Demo added for Model3D component event tracking
A new demo application has been added to the model3d\_component\_events directory that demonstrates how to track and respond to Model3D component events. The demo displays input and output 3D models alongside counters that increment when the model is uploaded, changed, or cleared, along with a text box that updates on clear events.
_demo/model3d\_component\_events, demo/video\_component\events · high confidence
Demo added for UploadButton component events
A new demo application has been added to the 'upload\_button\_component\_events' directory, demonstrating how to handle file upload events for both single and multiple file scenarios. The example shows how to link an UploadButton to a File output component and use Number components to track the count of files loaded and button clicks, providing a concrete reference for implementing these interactions.
_demo/upload\_button\_component\events · high confidence
Demo added for audio and video playback position control
A new demo application has been added at demo/playback\_position that demonstrates how to set and read the playback position for gr.Audio and gr.Video components. The demo includes tabs for both media types, allowing users to retrieve the current playback time in seconds and update the playback position via button clicks.
_demo/playback\position · high confidence
Demo adds File component delete event and file type handling examples
The demo application now includes a File component configured with a delete event, allowing users to see how deleted file data is captured and displayed. It also demonstrates various file type configurations, including single and multiple file uploads, specific type restrictions (images, videos, PDFs), compound file extensions (e.g., .nii.gz), and handling of invalid file types.
_demo/file\_component\events · high confidence
Demo adds autoscroll parameter to HTML component
The demo application for the HTML component now demonstrates the use of the \autoscroll\ parameter. By setting \autoscroll=True\ on the \gr.HTML\ instance, the component automatically scrolls to the bottom as new content is dynamically added via the \longer\ function, illustrating this specific behavior to users.
_demo/html\autoscroll · high confidence
Demo adds container=False examples for gr.Group
The demo application in demo/blocks\_group now includes examples demonstrating the use of the container=False parameter on elements like Textbox, Number, Image, and Radio within a gr.Group. This allows users to see how setting container=False removes the label, padding, and block border, placing elements directly on the background.
_demo/blocks\group · high confidence
Demo adds webcam resolution constraints for video and image inputs
The demo/webcam\_constraints/run.py script demonstrates how to enforce specific webcam resolutions (800x600) using the new \webcam\_options\ and \WebcamOptions\ API in Gradio. It provides two working examples—one for \gr.Video\ and one for \gr.Image\—showing users how to pass \constraints\ to limit the width and height of the webcam stream.
_demo/webcam\constraints · high confidence
Demo app adds line number toggle and CSS styling to Code component
The demo application in \demo/code\ now demonstrates the \show\_line\_numbers\ parameter on the \gr.Code\ component, allowing users to toggle line number visibility in the input and output code blocks. It also introduces a custom CSS file (\file.css\) that applies specific colors to code elements, and includes a button to load code content from this external CSS file.
demo/code · high confidence
Demo app demonstrating concurrent rendering with queue limits
A new demo application has been added at demo/render\_heavy\_concurrently that showcases the framework's ability to handle multiple concurrent render blocks. The app defines two separate render functions, each generating 500 text boxes, and configures the demo queue with a default concurrency limit of 64 to manage simultaneous requests.
_demo/render\_heavy\concurrently · high confidence
Demo app for Dataframe column width and wrapping behaviors
A new demo application has been added to the \demo/dataframe\_widths\ directory that illustrates how the \Dataframe\ component handles column sizing and text wrapping. The app showcases various configurations, including default auto-sizing, fixed pixel widths, percentage-based widths, and mixed sizing modes. It also demonstrates the interaction between the \wrap\ parameter and \column\_widths\, showing how content either truncates with an ellipsis or wraps to multiple lines depending on the settings. Additionally, the demo includes examples using \max\_chars\ to limit cell text length and \interactive=True\ for editable dataframes.
_demo/dataframe\widths · high confidence
Demo app for MCP resources and prompts
A new demo application has been added to showcase Model Context Protocol (MCP) capabilities, specifically resources and prompts. The demo includes two implementations: a standard FastMCP server example and a Gradio-based interface that integrates MCP tools, resources, and prompts into a tabbed UI. Users can now interact with a calculator tool, retrieve dynamic greetings via resources, and generate styled greeting prompts directly within the Gradio environment.
_demo/mcp\_resources\_and\prompts · high confidence
Demo app for audio component input and output events
A new demo application has been added to the \demo/audio\_component\_events\ directory that demonstrates the usage of \.input()\ and other event handlers on \gr.Audio\ components. The app displays real-time counters for various audio interactions, including upload, change, play, pause, and recording start/pause/stop events for both input and output audio components.
_demo/audio\_component\events · high confidence
Demo app for chained event listeners and error handling
The demo/blocks\_chained\_events/run.py file has been added to demonstrate chaining events (success/failure) on Gradio Blocks, including handling errors raised by gr.Error and standard exceptions, as well as triggering status modals for warnings and info messages.
_demo/blocks\_chained\events · high confidence
Demo app for gr.render capabilities
Added a new demo application (demo/render\_tests/run.py) that showcases the gr.render component's features, including dynamic rendering based on slider inputs, event-driven re-renders triggered by button clicks and chat selections, support for event and SelectData in render blocks, nested tabs within rendered sections, and timer-based updates.
_demo/render\tests · high confidence
Demo app for toggling component visibility
Added a new demo application in \demo/invisible\_textbox/run.py\ that demonstrates how to dynamically show and hide various Gradio components (such as Textbox, Markdown, Accordion, and Slider) across different tabs and interactive states using button clicks.
_demo/invisible\textbox · high confidence
Demo app illustrating scroll-to-output behavior
A new demo application at demo/blocks\_scroll demonstrates the scroll\_to\_output parameter in Gradio Blocks. The app includes two buttons: one that triggers an output update with automatic scrolling to the result, and another that updates the output without scrolling, allowing users to see the difference in user experience.
_demo/blocks\scroll · high confidence
Demo app now supports custom JavaScript injection via the \`js\` parameter
The \demo/blocks\_js\_load\ example demonstrates how to pass a custom JavaScript string to \gr.Blocks().launch()\. This allows users to inject client-side scripts that manipulate the DOM, such as creating animations or modifying UI elements, directly from the Python application code.
_demo/blocks\_js\load · high confidence
Demo app preserves query parameters across navbar navigation
The demo application in the navbar\_query\_params location now demonstrates how to maintain query parameters (specifically an 'option' value) when navigating between pages using the Navbar component. Selecting a value in the dropdown updates the URL's query string and dynamically adjusts the Navbar links to include that parameter, ensuring the selection persists when moving to the second page.
_demo/navbar\_query\params · high confidence
Demo app showcases DataFrame styling via pandas Styler
A new demo application in the \demo/dataframe\_colorful\ directory demonstrates how to apply visual styling to a \gr.DataFrame\ component. The example creates a pandas DataFrame and uses the \df.style.highlight\_max\ method to highlight maximum values in light green, passing the resulting styled object directly to the Gradio component to render the formatted table.
_demo/dataframe\colorful · high confidence
Demo app showcases custom JavaScript methods for client-side processing
A new demo application in the \demo/blocks\_js\_methods\ directory illustrates how to use the \js\ parameter in Gradio Blocks to execute custom JavaScript functions on the client side. The app demonstrates several use cases, including reversing text strings, appending static content, and chaining client-side transformations before sending data to the server, providing a practical example for users looking to integrate custom frontend logic with Gradio components.
_demo/blocks\_js\methods · high confidence
Demo app showcasing Mermaid diagram rendering in Markdown
A new demo application has been added at demo/markdown\_with\_mermaid that demonstrates rendering Mermaid diagrams (including graphs, sequence diagrams, flowcharts, and state diagrams) within Gradio's Markdown component.
_demo/markdown\_with\mermaid · high confidence
Demo application for state change and render block behaviors
Added a new demo application at demo/state\_change/run.py that illustrates various state management patterns in Gradio. The demo showcases state changes triggered by button clicks and input changes, including updates to primitive types (numbers), complex structures (lists, dicts, sets), and custom objects with hash implementations. It also demonstrates the use of @gr.render blocks that react to state inputs to dynamically generate UI components, as well as async state updates via iterators.
_demo/state\change · high confidence
Demo applications for randomizing slider values
Added two new demo applications (blocks and interface) that showcase the \randomize=True\ parameter on \gr.Slider\ components. These demos illustrate how sliders can be initialized with random values within their defined ranges and steps, including examples with large ranges, specific step increments, and mixed random/non-random inputs.
_demo/interface\_random\slider · high confidence
Demo apps added for thinking LLM nested and linear thought processes
Added two new demo applications (\demo/chatinterface\_thoughts\ and \demo/chatinterface\_nested\_thoughts\) that showcase how to use the \ChatMessage\ component with metadata to display intermediate 'thinking' steps in a \gr.ChatInterface\. The linear thought demo illustrates a single thinking block that updates progressively before revealing the final answer, while the nested thought demo demonstrates a more complex structure with parent-child relationships between thought steps, including status tracking and duration metadata.
_demo/chatinterface\_nested\_thoughts, demo/chatinterface\thoughts · high confidence
Demo apps demonstrate keyword-only argument mapping for event inputs
Two new demo applications illustrate how to map Gradio UI components to function parameters using keyword arguments. The simple demo shows a greeting function where the first name is passed as a positional input and the last name is passed via keyword mapping. The inventory explorer demo applies this pattern to a more complex filtering function, mapping search text, category, price, stock status, sort order, and result limit to their respective UI controls, allowing users to see how explicit named parameters can be bound to interface elements.
_demo/keyword\_inputs\_inventory, demo/keyword\_inputs\simple · high confidence
Demo apps expose Model3D camera and ImageSlider state to event handlers
New demo applications in the \demo/component\_props\ and \demo/model3d\_camera\_position\ directories illustrate how to read and manipulate component state via event handlers. The \component\_props\ demo shows how to retrieve and reset the \camera\_position\ for \Model3D\ components and the \slider\_position\ for \ImageSlider\ components, as well as how to dynamically update \Number\ and \Image\ properties. The \model3d\_camera\_position\ demo demonstrates capturing a 2D snapshot from the current 3D camera viewpoint by accessing the \camera\_position\ attribute within a function.
_demo/component\props · high confidence
Demo apps now expose tools via MCP server
The \demo/mcp\_tools\ and \demo/letter\_counter\ applications can now run as Model Context Protocol (MCP) servers by passing \mcp\_server=True\ to \demo.launch()\. This allows external clients to discover and invoke the demo's functions (such as letter counting, prime factorization, and image processing) as standardized tools. The \mcp\_tools\ demo also demonstrates granular API control, including setting custom descriptions, hiding specific interfaces from the API, and disabling API exposure for certain tools.
_demo/mcp\tools · high confidence
Demo apps now support thought logs and nested thought structures
The chatbot demo applications have been updated to showcase advanced reasoning visualization features. The 'chatbot\_thoughts' demo now supports a \log\ parameter in message metadata, allowing users to see detailed status strings (such as step completions) alongside the thought title. Additionally, a new 'chatbot\_nested\_thoughts' demo has been added to demonstrate how thoughts can be structured hierarchically using parent-child relationships, enabling the display of nested reasoning chains with success and error states.
_demo/chatbot\thoughts · high confidence
Demo chat interface now supports preset response options
The \demo/chatinterface\_options\ demo has been updated to showcase the new ability to provide preset response options in \gr.ChatInterface\. The demo's chat function now returns a \gr.ChatMessage\ object containing an \options\ list, allowing users to select from predefined responses (e.g., "Yes" or "No") instead of typing free text, demonstrating how this feature integrates with the chat interface.
_demo/chatinterface\options · high confidence
Demo for ImageEditor event tracking and clear behavior
A new demo script has been added to the \demo/image\_editor\_events\ location that demonstrates how the \ImageEditor\ component handles various events. The demo sets up an \ImageEditor\ alongside preview and label components to track and display the counts for upload, change, input, and apply events. It also includes a 'Clear Button' to verify that the editor's value is correctly cleared to None, ensuring the component behaves as expected when reset.
_demo/image\_editor\events · high confidence
Demo for gr.Image event handling
A new demo application has been added at demo/image\_component\_events/run.py that demonstrates the event capabilities of the gr.Image component. The demo showcases how to bind and track various events including upload, input, change, clear, and select, updating corresponding counters in the UI to verify that each event triggers as expected.
_demo/image\_component\events · high confidence
Demo for pre-populated chatbot feedback
The chatbot feedback demo now includes a 'Test Liked Loading' button that demonstrates how to initialize a chat history with pre-set feedback values (specifically a 'Like') on assistant messages using the feedback\_value parameter.
_demo/chatbot\feedback · high confidence
Demo for video subtitle injection
A new demo application has been added to the \demo/video\_subtitle\ directory that allows users to upload a video file along with a subtitle file (supporting .srt, .vtt, and .json formats) to generate an output video with the subtitles embedded.
_demo/video\subtitle · high confidence
Demo introduces decorator syntax for event listeners
The demo application at demo/hello\_blocks\_decorator now demonstrates the new decorator-based syntax for attaching event listeners to components. Users can see how the @component.click decorator simplifies binding input and output components to handler functions, replacing the previous context-manager style for defining interactions like the 'Greet' button.
_demo/hello\_blocks\decorator · high confidence
Demo now includes a ClearButton and tab-switching logic
The demo application has been updated to demonstrate the new gr.ClearButton component, which allows users to clear the associated textbox in the 'Text Input' tab. Additionally, the demo now includes interactive tab switching: a 'Change tab' button programmatically switches the active tab to the third one, and each tab item has a select event handler to ensure the tab state remains consistent when clicked directly.
_demo/blocks\plug · high confidence
Demo script for loading a Gradio Space
A new demo script has been added to the load\_space directory that demonstrates how to load a Gradio application from a remote Space using the gr.load() function with the src parameter set to 'spaces'.
_demo/load\space · high confidence
Demo showcases DataFrame markdown and HTML rendering
The demo application now includes a DataFrame component that renders Markdown and HTML content within its cells. By setting the \datatype\ parameter to include 'markdown' and 'html', users can see how the component interprets and displays formatted text and images, demonstrating the output capabilities of the DataFrame block.
_demo/blocks\outputs · high confidence
Demo showcases editable chatbot messages with change tracking
The new demo at demo/chatbot\_editable illustrates the ability to edit individual messages within a Gradio Chatbot component. It demonstrates how users can modify chat history entries and how the system captures the previous value, new value, and index of the edited message, displaying this change information in a separate text box.
_demo/chatbot\editable · high confidence
Demo showcases interactive Dataframe features and event handling
The demo application now includes a comprehensive example of the gr.Dataframe component, demonstrating interactive capabilities such as cell editing, row selection, and filtering. It highlights specific configuration options including static columns, search modes (filter vs. search), and custom data types (string, number, boolean). The demo also illustrates how to handle and display various dataframe events like edits, selections, and input changes through dedicated counters and text outputs.
_demo/dataframe\events · high confidence
Demo showcasing additional inputs in Interface
A new demo file has been added to the \interface\_with\_additional\_inputs\ location, demonstrating how to use the \additional\_inputs\ parameter in \gr.Interface\. This example configures an interface that accepts a text prompt and a seed slider as additional inputs, alongside an optional initial image, to generate a fake image output.
_demo/interface\_with\_additional\inputs · high confidence
Demo showcasing custom dataframe styling with conditional formatting and display overrides
Added a new demo application in demo/dataframe\_custom\_styling that illustrates how to apply custom visual styles and modify cell display values within a Gradio Dataframe component. The example demonstrates using the metadata field to inject CSS-based background gradients proportional to numeric values and to prepend rank medals to the top three entries, providing a concrete reference for users implementing similar custom dataframe presentations.
_demo/dataframe\_custom\styling · high confidence
Demo showcasing event cancellation capabilities
Added a new demo application that illustrates how to cancel running events, such as iterative outputs and expensive calculations, using various triggers including button clicks, input changes, submissions, and media interactions.
_demo/cancel\events · high confidence
Demo showcasing intermediate function caching with gr.cache()
Added a new demo application that illustrates how to apply \gr.cache()\ directly to intermediate helper functions within a larger processing pipeline. The demo simulates a support assistant where an expensive, deterministic retrieval step is cached, allowing subsequent calls with the same inputs (such as changing only the answer tone) to reuse the cached result instead of re-executing the heavy operation.
_demo/cache\_intermediate\demo · high confidence
Demo showcasing multiple event triggers for LinePlot
A new demo application has been added to the \demo/blocks\_multiple\_event\_triggers\ directory that demonstrates how to bind multiple event triggers (dropdown changes and page load) to a single function. The app uses Gradio's \LinePlot\ component to display PyPI download statistics for various libraries, updating the chart dynamically when the user selects a different library or time range.
_demo/blocks\_multiple\_event\triggers · high confidence
Demo shows copy events on Markdown, Chatbot, and Textbox
The demo/copy\_events example demonstrates how to capture copy actions from gr.Markdown, gr.Chatbot, and gr.Textbox components. It configures these components with a 'copy' button and uses gr.on to listen for their copy events, routing the copied value to a target textbox via a callback.
_demo/copy\events · high confidence
Demo updates: custom CSS capabilities and tab visibility behavior
The demo suite now includes a custom CSS example demonstrating support for advanced CSS rules like @media queries, @keyframes animations, @font-face, and @import statements, allowing users to see these features in action within Gradio Blocks. Additionally, a new demo illustrates the behavior of tabs with visible=False, showing that such tabs are hidden by default and can be made visible via event handlers.
_demo/custom\css · high confidence
Demo: BrowserState component with LocalStorage persistence
The demo/browserstate example now demonstrates the gr.BrowserState component, allowing users to save and retrieve data (such as username and password) from the browser's local storage. The demo shows how state changes trigger events to persist values and how the application loads previously saved data on page load, retaining user input across refreshes.
demo/browserstate · high confidence
Demo: Textbox component now supports custom buttons
A new demo in the \demo/textbox\_custom\_buttons\ directory illustrates how to attach custom buttons to a Textbox component. The example shows buttons triggering Python functions (e.g., refreshing data) and JavaScript functions (e.g., showing an alert or clearing the text), demonstrating the integration of custom button actions with the Textbox UI.
_demo/textbox\_custom\buttons · high confidence
Gallery component now exposes preview\_open and preview\_close events
Users can now track when a user opens and closes the image/video preview in a Gallery component. This demo adds \preview\_open\ and \preview\_close\ event handlers to the output gallery, allowing applications to react to these specific user interactions (e.g., updating UI state or logging), in addition to existing upload, change, and select events.
_demo/gallery\_component\events · high confidence
Gallery selection demo now supports image darkening
A new demo at demo/gallery\_selections demonstrates how to handle gallery selections. It allows users to select an image from a gallery, darken it using a button, and deselect images, showcasing the use of the gallery's select event and state management.
_demo/gallery\selections · high confidence
Image watermarking demo with configurable positioning
A new demo application has been added to the image\_watermark location that allows users to apply a watermark image to a base image. The demo exposes two input fields for the original and watermark images, and uses the WatermarkOptions component to position the watermark at the bottom-left of the output image.
_demo/image\watermark · high confidence
Initial release of the standalone gradio\_client Python library
The \gradio\_client\ package is now available as a standalone, lightweight Python library (installable via \pip install gradio\_client\) that allows users to interact with any Gradio app or Space as an API. This new client supports connecting to public and private Spaces (with optional Hugging Face token authentication), duplicating Spaces for private use, inspecting API endpoints, and making predictions. It is designed to work with Python 3.10 or higher and includes a dedicated README with usage examples.
client/python · high confidence
Introduce new JavaScript client library
The JavaScript client library has been rewritten from scratch, introducing a new \Client\ class in \client/js/src/client.ts\ that manages configuration, API calls, and streaming connections. This update adds support for private Hugging Face Spaces via cookie and token authentication, implements a heartbeat mechanism for connection health, and provides a new \submit\ API that returns an \AsyncIterable\ for handling streaming responses. The client now includes built-in run history management with browser-local storage and Hugging Face bucket sync, supports file uploads with size limits, and exposes status callbacks and error handling for better developer experience.
client/js/src · high confidence
Introduction of a simple chatbot demo with a clear button
A new demo application has been added at demo/chatbot\_simple that demonstrates a basic chatbot interface using Gradio. The interface includes a chat history display, a text input box, and a newly introduced ClearButton component that allows users to reset both the input and the chat history. The bot responds with random static messages after a short delay to simulate processing time.
_demo/chatbot\simple · high confidence
MCP server support added to Gradio demos
The demo application in demo/mcp\_progress now exposes its interface as an MCP server. By launching the demo with the mcp\_server=True flag, users can connect external MCP clients to interact with the text-reversing functionality, enabling programmatic access to the demo's capabilities via the Model Context Protocol.
_demo/mcp\progress · high confidence
Mini leaderboard demo adds custom styling and static model data
The mini\_leaderboard demo now includes a dedicated assets folder containing custom CSS and a static JSON dataset. The new CSS applies specific styling to the leaderboard table, such as hiding the final evaluation column, limiting the width of model name columns, and adjusting font sizes and margins for better readability. The leaderboard\_data.json file provides a static list of models with their names and links to Hugging Face, enabling the demo to render a pre-populated leaderboard view without requiring dynamic data fetching.
_demo/mini\leaderboard · high confidence
Native plot demos with export and draggable layout support
The demo/native\_plots area now includes runnable examples for Line, Scatter, and Bar plots that utilize the native plot components. These demos demonstrate interactive features such as time-based binning, aggregation, and axis limiting via DateTime inputs, as well as the ability to export plots. Additionally, the demos showcase the new gr.Draggable layout component, allowing users to reorder charts within a dashboard.
_demo/native\plots · high confidence
New Airbnb map demo added
A new demo application has been added to the \demo/map\_airbnb\ directory that displays an interactive map of New York City Airbnb listings using Plotly. The demo loads data from the HuggingFace \gradio/NYC-Airbnb-Open-Data\ dataset and allows users to filter listings by price range and borough (Queens, Brooklyn, Manhattan, Bronx, Staten Island), updating the map visualization in real-time.
(repo-wide) · high confidence
New Animal Generator demo with dynamic UI updates
Added a new demo application in demo/blocks\_update/run.py that demonstrates dynamic interface updates using Gradio Blocks. The app features an 'Animal Generator' where selecting a species (Mammal, Fish, or Bird) dynamically populates a dropdown with specific animals and reveals a hidden details panel. The interface further adapts based on user interaction: selecting certain animals (Elephant, Shark, Giraffe) increases the weight slider's maximum value to 100, while others keep it at 20, and the number of lines in the 'Extra Details' textbox adjusts based on the selected weight value.
_demo/blocks\update · high confidence
New Blocks Flipper demo with Accordion component
A new demo application has been added at demo/blocks\_flipper that showcases text and image flipping capabilities. The interface uses Gradio Blocks to organize functionality into tabs for text and image inputs, and introduces the new gr.Accordion component to hide additional controls (a slider) behind a collapsible section.
_demo/blocks\flipper · high confidence
New Blocks demo showcasing combined text and image inputs with cached examples
A new demo application has been added to the \demo/blocks\_inputs\ directory that demonstrates a Gradio Blocks interface handling both text and image inputs. The app allows users to combine two text strings or mirror an image via buttons, and includes \gr.Examples\ components for both text and image inputs with example caching enabled to improve performance.
_demo/blocks\inputs · high confidence
New Blocks essay demos added
Added two new demo applications in the \demo/blocks\_essay\ and \demo/blocks\_essay\_simple\ directories. The \blocks\_essay\ demo showcases interactive state management, including dynamic textbox resizing based on radio selection, cascading dropdowns for country/city selection, number input bounds controlled by sliders, and a toggleable column visibility feature. The \blocks\_essay\_simple\ demo provides a minimal example of changing textbox properties (lines and visibility) via a radio button selection.
_demo/bar\_plot, demo/line\_plot, demo/blocks\essay · high confidence
New ChatInterface demo cases for multimodal and editable modes
Added four new demo scripts in the \test\_chatinterface\_streaming\_echo\ directory to showcase specific ChatInterface capabilities. \multimodal\_group\_messages\_testcase.py\ and \multimodal\_messages\_testcase.py\ demonstrate streaming echo behavior with multimodal input enabled. \multimodal\_non\_stream\_testcase.py\ provides a non-streaming counterpart for multimodal inputs. \run.py\ illustrates the newly supported \editable=True\ parameter alongside \fill\_height\, allowing users to edit messages before submission in a streaming context.
_demo/test\_chatinterface\_streaming\echo · high confidence
New ChatInterface demos for streaming, flagging, and history saving
Added two new demo applications for the ChatInterface component: one demonstrating streaming responses with manual flagging options (Like, Spam, Inappropriate, Other) and history persistence, and another showcasing multimodal input handling with multiple file uploads and history saving.
_demo/chatinterface\_streaming\echo · high confidence
New Chicago Bike Share Dashboard demo
Added a new demo application that connects to a PostgreSQL database to visualize Chicago bike share data from March 2022. The dashboard displays two bar plots: one showing the number of rides per bicycle type and another highlighting the five most popular stations, with data loaded dynamically via Gradio's event system.
demo/chicago-bikeshare-dashboard · high confidence
New DALL·E mini image generation demo
A new demo application has been added to the \demo/blocks\_joined\ directory that showcases the DALL·E mini model. Users can enter a text prompt and click 'Run' to generate a gallery of nine images, which are retrieved using Gradio's built-in sample media utilities. The interface includes a styled markdown header, a text input field, and a responsive gallery layout.
_demo/blocks\joined · high confidence
New Dataset and UploadButton component demos
Added demo applications for the Dataset and UploadButton components. The Dataset demo showcases a text dataset with a hidden textbox component and predefined samples, while the UploadButton demo demonstrates uploading multiple image or video files and displaying the file paths.
_demo/dataset\_component, demo/uploadbutton\component · high confidence
New Deep Link Demo with Cached Examples
A new demo application has been added at demo/chatinterface\_deep\_link that showcases Gradio's deep linking capabilities. The demo features a ChatInterface with a slow-echo response and a separate cached example interface, both configured to support deep links for sharing specific states or inputs.
_demo/chatinterface\_deep\link · high confidence
New Dia Dialogue and Audio Diarization demos
Added two new Gradio demo applications: a Dia Dialogue demo that generates realistic multi-speaker audio from text conversations using the Dia-1.6B model via Fal AI, and an Audio Diarization demo that separates speakers and transcribes audio files using pyannote and Whisper. Both demos utilize the new gr.Dialogue component to manage multi-turn, multi-speaker interactions.
_demo/dia\_dialogue\demo · high confidence
New Dialogue component demo for multi-speaker conversations
A new demo application has been added for the gr.Dialogue component, showcasing its ability to handle multi-speaker conversations with configurable speaker labels and emotion tags. The example demonstrates initializing the component with specific speakers and tags, pre-populating a conversation history, and submitting user input to an output textbox.
_demo/dialogue\component · high confidence
New Discord bot deployment template for Gradio apps
A new template file (\discord\_chat.py\) has been added to the Gradio client templates, enabling users to deploy their Gradio applications as Discord bots. This template provides the necessary code to connect a Gradio app to a Discord bot, handling command processing, thread creation for conversations, and response truncation to comply with Discord API limits.
_client/python/gradio\client/templates · high confidence
New DownloadButton component for file downloads
Gradio now includes a \gr.DownloadButton\ component, allowing users to trigger file downloads directly from the interface. This new component is demonstrated in the \downloadbutton\_component\ demo, which shows a static download link, and in the \upload\_and\_download\ demo, which illustrates a workflow where a file is uploaded and then made available for download via the new button.
_demo/downloadbutton\_component, demo/upload\_and\download · high confidence
New English-to-German translation demo
A new demo application has been added at demo/generate\_english\_german that demonstrates a two-step translation pipeline. Users can input a phrase, which is first expanded into English using a DistilGPT-2 text generation model, and then translated into German using the 'spaces/gradio/english\_translator' component. The interface provides a simple text input, displays both the generated English and final German text, and includes example inputs for quick testing.
_demo/generate\_english\german · high confidence
New FD-GAN demo with custom error handling and queue configuration
A new demo application located at demo/fake\_gan\_2/run.py has been added, showcasing a fake GAN interface that generates random images. This demo introduces specific behavioral features for testing and demonstration purposes: it raises a custom Gradio error when the input description is 'NSFW', raises a standard ValueError for the input 'error', and configures the demo's queue with a maximum size of 3 to manage concurrent requests.
_demo/fake\_gan\2 · high confidence
New File Explorer events demo with dynamic root and filtering
A new demo application has been added to the \demo/file\_explorer\_component\_events\ directory, illustrating how to use the FileExplorer component's change events and dynamic configuration. The demo allows users to switch the explorer's root directory via a dropdown, toggle text-file-only or ignore-text-file filters using checkboxes, and view the total number of changes detected by the component. It also demonstrates retrieving the currently selected file path via a button click.
_demo/file\_explorer\_component\events · high confidence
New FileExplorer demo showcasing multi-file selection and code preview
A new demo application has been added to the \demo/file\_explorer\ directory, illustrating the capabilities of the \FileExplorer\ component. It demonstrates two key interactions: first, selecting multiple files from a directory tree and passing them to another \FileExplorer\ instance, and second, selecting a single Python file to automatically display its content in a \Code\ block. This provides users with a concrete example of how to configure \FileExplorer\ with glob patterns, root directories, and file count constraints for both multi-select and single-select workflows.
_demo/file\explorer · high confidence
New Flashcards demo application
Added a new interactive flashcard practice demo in the \demo/blocks\_flashcards\ directory. The application allows users to load word pairs into a table, then switch to a Practice tab to review cards by flipping them to reveal answers and marking them as correct or incorrect. It tracks statistics for correct and incorrect answers, displaying the results in a dedicated tab that becomes visible upon interaction.
_demo/blocks\_flashcards, demo/stock\forecast · high confidence
New GPT-2 text completion demo using Gradio
A new interactive demo has been added at demo/blocks\_gpt/run.py that allows users to generate text completions using the GPT-2 XL model. The application uses the Gradio framework to provide a simple interface where users can type text, and the system generates a completion based on the last 50 characters of the input.
_demo/blocks\gpt · high confidence
New Gradio demos for Coqui TTS and Prophet forecasting
Added two new interactive Gradio demos to the website. The Neon TTS Plugin Coqui demo allows users to convert text to speech in 14 languages, requiring system packages libsndfile1 and espeak-ng. The Timeseries Forecasting with Prophet demo displays PyPI download statistics for Python libraries and provides a 3-month forecast using the Prophet library, with options to select the library and time range.
demo/neon-tts-plugin-coqui, demo/timeseries-forecasting-with-prophet · high confidence
New Hugging Face OAuth login demo
A new demo application has been added to the \demo/login\_with\_huggingface\ directory that demonstrates how to use Gradio's OAuth integration with Hugging Face. The application displays a login button and, upon successful authentication, greets the user by name and lists their associated organizations using the Hugging Face Hub API.
_demo/login\_with\huggingface · high confidence
New Image Editor demo with brush, eraser, and layer controls
A new demo application (\demo/image\_editor\) showcases the \ImageEditor\ component, demonstrating event tracking for uploads, changes, and inputs. A second demo (\demo/image\_editor\_many\) provides interactive examples for configuring brush options (size, opacity, color), eraser settings, and layer management (enabling/disabling layers, adding masks), allowing users to see how these UI controls update the editor state in real time.
_demo/image\editor · high confidence
New Image Editor demos demonstrating canvas sizing and story workflows
Added two new demo applications for the ImageEditor component. The \image\_editor\_canvas\_size\ demo illustrates how to configure and retrieve image data using default, custom, and fixed canvas sizes via the \canvas\_size\ and \fixed\_canvas\ parameters. The \image\_editor\_story\ demo provides a complete workflow example, allowing users to edit an image with a specified background and brush colors, then save the result to a file and display it in the UI.
_demo/image\_editor\_canvas\size · high confidence
New Image Editor layers demo
Added a new demo application in \demo/image\_editor\_layers\ that showcases the \ImageEditor\ component's support for image layers. The demo allows users to manipulate background images, layer images, and composite images, while displaying the number of layers and layer updates in real-time.
_demo/image\_editor\layers · high confidence
New JavaScript client library type definitions
The \@gradio/client\ package now includes a comprehensive set of TypeScript declaration files (\.d.ts\) for its client-side API. This adds type definitions for the \Client\ class, covering methods for connecting, predicting, submitting events, and uploading files, as well as types for configuration, API info, and space status. It also exposes types and utilities for handling run history, blob data, and file uploads, providing better IDE support and type safety for developers using the Gradio JavaScript client.
home/runner/work/gradio/gradio/client/js · high confidence
New LLM demo applications for Claude and LlamaIndex RAG
Added two new interactive demo applications to the \demo\ directory. The \demo/llm\_claude\ entry point provides a 20-questions game using the Anthropic API and Gradio, while \demo/llamaindex\ offers a Retrieval-Augmented Generation (RAG) chatbot that allows users to upload text or PDF files to query against using Llama Index and Gradio.
_demo/llm\_claude, demo/llm\llamaindex · high confidence
New LangChain and Gradio chatbot demo
A new demo application has been added at demo/llm\_langchain/run.py that demonstrates a simple general-purpose chatbot built using LangChain and Gradio. The example uses the ChatOpenAI model (gpt-4o-mini) and implements a chat interface via Gradio's ChatInterface component, handling message history conversion between Gradio's format and LangChain's message objects.
_demo/llm\langchain · high confidence
New Model3D demo showcasing wireframe display and diverse 3D formats
A new demo application has been added to the model3D location, demonstrating the gr.Model3D component with a wireframe display mode. The demo allows users to load and visualize various 3D file formats, including OBJ, GLB, GLTF, STL, and PLY, as well as Gaussian Splatting (.splat) files from remote URLs. It includes example inputs for several sample models (Bunny, Duck, Fox, face, sofia) and a remote bonsai splat file, providing a practical reference for integrating 3D model rendering into Gradio applications.
demo/model3D · high confidence
New NER Pipeline Demo with Gradio Interface
A new interactive demo has been added for the Named Entity Recognition (NER) pipeline. Users can now launch a Gradio-based web interface that accepts text input and displays extracted entities using the Hugging Face \transformers\ pipeline, providing a quick way to test NER capabilities directly from the demo directory.
_demo/ner\pipeline · high confidence
New Outbreak Forecast demo with multi-library plot support
A new demo application has been added to the outbreak\_forecast location, allowing users to generate outbreak plots based on five inputs: plot type, reproduction number (R), month, selected countries, and a social distancing toggle. The application supports four distinct visualization libraries—Matplotlib, Plotly, Altair, and Bokeh—selected via a dropdown, and includes cached examples for quick interaction.
_demo/outbreak\forecast · high confidence
New Progress Bar demo showcasing tracking capabilities
A new demo application has been added at demo/progress/run.py that demonstrates the Gradio Progress component. It provides interactive examples for tracking progress from Python lists, nested lists, and iterables of unknown length, as well as manual progress updates, nested progress calls, and automatic tracking of external tqdm loops and internal library operations.
demo/progress · high confidence
New RT-DETR video object detection demo
Added a new interactive demo in the \demo/rt-detr-object-detection\ directory that allows users to upload a video and stream back processed output with bounding boxes drawn around detected objects. The demo uses the \PekingU/rtdetr\_r50vd\ model via Gradio, featuring a confidence threshold slider and real-time video streaming output.
demo/rt-detr-object-detection · high confidence
New Seafoam theme demo with custom styling
A new demo application has been added to the theme\_new\_step\_3 location that showcases a custom 'Seafoam' theme. This theme applies a repeating diagonal gradient background, specific color palettes for primary and secondary hues, and distinct styling for buttons and sliders. The demo includes a simple interface with a text input, a slider, and a submit button to demonstrate the theme's visual properties in action.
_demo/theme\_new\_step\3 · high confidence
New Spaces test application for client and embed testing
A new test application has been added to \js/\_spaces-test\ to validate the Gradio JavaScript client and embedding behavior. The app includes a 'Client Browser' page that allows users to connect to a Hugging Face Space via the \@gradio/client\, inspect its API endpoints, and submit requests to observe responses. It also features an 'Embeds' page that loads a Gradio app inside an iframe using \iframe-resizer\ to test sizing and interaction in an embedded context. The application is built with Svelte 5, utilizing runes for state management, and includes a shared theme and UI components for consistent styling.
_js/\spaces-test · high confidence
New Speech-to-Text and Text-to-Speech demo app
A new interactive demo application has been added at demo/stt\_or\_tts/run.py, providing a unified interface for Speech-to-Text (STT) and Text-to-Speech (TTS) capabilities. The app uses Gradio to present two tabs: one for TTS using the facebook/fastspeech2-en-ljspeech model, and another for STT using the facebook/wav2vec2-base-960h model, allowing users to input text or audio to see immediate results.
_demo/stt\_or\tts · high confidence
New Tic-Tac-Toe demo showcasing the .select event
A new interactive Tic-Tac-Toe demo has been added to the demo/tictactoe directory. This example demonstrates the usage of the .select event listener on a gr.Dataframe component, allowing users to click on cells to place their mark and toggle turns between X and O.
demo/tictactoe · high confidence
New Timer demo showcasing interval and event-driven updates
A new demo application has been added at demo/timer/run.py that demonstrates the gr.Timer component. The demo illustrates how to use timers for periodic updates (such as refreshing a timestamp every second) and how to control timer activity via start/stop buttons, as well as dynamically adjusting the interval using additional controls.
demo/timer · high confidence
New Titanic Survival and Zip-to-JSON demos added
Two new demonstration applications have been added to the Gradio package. The Titanic Survival demo showcases a machine learning workflow using scikit-learn's RandomForestClassifier to predict passenger survival based on input features like class, age, and fare, presented via a Gradio Interface with live prediction. The Zip-to-JSON demo provides a utility for extracting metadata (filename, size, compressed size) from uploaded ZIP files and returning the results as JSON.
_demo/titanic\survival · high confidence
New Transformers agent chatbot demo with image generation
A new demo application has been added at demo/agent\_chatbot/run.py that showcases a ReactCodeAgent powered by the Qwen2.5-Coder-32B-Instruct model. This interactive chatbot integrates a FLUX.1-schnell image generation tool, allowing users to request illustrations via natural language prompts within a Gradio interface.
_demo/agent\chatbot · high confidence
New TypeScript definitions for Gradio helper utilities
A new TypeScript declaration file (gradio\_helper.d.ts) has been added to the core module, exposing type definitions for the Gradio class, the I18nFormatter type, and the formatter and reactive\_formatter functions. This provides static typing support for internationalization formatting utilities used within the Gradio JavaScript core.
home/runner/work/gradio/gradio/js/core · high confidence
New UniSpeech-SAT speaker verification demo
A new interactive demo has been added for the \demo/unispeech-speaker-verification\ location, allowing users to compare two audio recordings to determine if they come from the same speaker. The interface uses the \microsoft/unispeech-sat-base-plus-sv\ model to extract embeddings and calculates cosine similarity, displaying a success message if the score exceeds 85% or a failure message otherwise. It includes built-in examples and handles audio preprocessing via SoX effects.
demo/unispeech-speaker-verification · high confidence
New VLM chat demo for image-text-to-text models
Added a new demo in the \workflow\_vlm\_chat\ directory that provides a Gradio-based interface for asking questions about images using a vision-language model. The demo is powered by a \workflow.json\ definition that wires an image input and a text prompt into the \Qwen/Qwen3.8-27B\ model (via the \chat\_completion\ endpoint on \featherless-ai\) and displays the resulting text answer, allowing users to interact with image-text-to-text models through a simple canvas view.
_demo/workflow\_vlm\chat · high confidence
New X-ray disease detection demo
A new demo application has been added at demo/blocks\_xray/run.py that allows users to detect diseases from medical scans. The app features a tabbed interface with separate sections for X-ray and CT scan analysis, using CheckboxGroup inputs to select target diseases and displaying results in JSON format. It includes duplicate functionality and an upload button for sharing results.
_demo/blocks\xray · high confidence
New XGBoost Income Prediction demo with Shapley explanations
A new interactive demo has been added that allows users to predict income based on demographic inputs (age, workclass, education, etc.) using an XGBoost classifier. The demo includes a separate 'Explain' button that generates a bar chart of feature Shapley values, providing interpretability for the model's predictions.
demo/xgboost-income-prediction-with-explainability · high confidence
New ZIP file bundling demo
A new demo application has been added to the \demo/zip\_files\ directory that allows users to upload multiple text, JSON, or CSV files and download them bundled into a single ZIP archive. The interface accepts multiple file inputs restricted to specific extensions and provides example data for immediate testing.
_demo/zip\files · high confidence
New audio debugger and simple image demos added
The demo/audio\_debugger and demo/image-simple directories now contain runnable Python scripts. The audio debugger demo showcases Gradio's audio capabilities across tabs, including static file playback, interface-based processing, and streaming audio, while also demonstrating how to access the user's IP address via the request object. The simple image demo provides a basic example of passing an image input to an output via a button click.
_demo/audio\debugger · high confidence
New audio mixer demo with dynamic track management
Added a new demo application in demo/audio\_mixer/run.py that allows users to dynamically add audio tracks and adjust their individual volumes. The interface renders a new column for each track containing a name textbox, an audio input component, and a volume slider. A 'Merge Tracks' button combines all active tracks into a single output audio stream, handling shape alignment and volume scaling for the final mix.
_demo/audio\mixer · high confidence
New caching demos for @gr.cache() and gr.Cache
Added three demo applications illustrating the new caching capabilities: \cache\_demo\ shows the \@gr.cache()\ decorator handling sync functions, async functions, text generators, streaming audio, and async generators; \cache\_kv\_demo\ demonstrates using \gr.Cache\ for manual key-value storage to reuse transformer KV caches across prompt prefixes; and \cache\_manual\_demo\ provides a simple example of manual cache lookups and storage for weather data.
_demo/cache\_demo, demo/cache\_kv\_demo, demo/cache\_manual\demo · high confidence
New calculator demos demonstrating default values and example caching
Two new demo applications have been added to the \demo/calculator\_blocks\ directory to illustrate specific Gradio Blocks features. The \run.py\ demo shows how to set default values for input components (such as initial numbers) and configure example inputs. The \run.py\ in \demo/calculator\_blocks\_cached\ demonstrates how to cache example outputs using the \cache\_examples=True\ parameter, improving performance for repeated example interactions.
_demo/calculator\blocks · high confidence
New chatbot streaming demo with clear functionality
A new demo application has been added at demo/chatbot\_streaming/run.py that demonstrates streaming responses in a chatbot interface. The demo features a chatbot component, a text input for user messages, and a 'Clear' button to reset the conversation history. It illustrates how to implement streaming by yielding partial responses character-by-character, simulating a real-time bot interaction.
_demo/chatbot\streaming · high confidence
New client utility modules for run history, streaming, and file handling
The JS client now includes a suite of new utility modules in \client/js/src/utils\ that enhance core capabilities. \run\_history.ts\ and \bucket\_sync.ts\ introduce browser-local and Hugging Face Hub bucket-based run history, allowing users to persist and retrieve past app runs. \stream.ts\ implements Server-Sent Events (SSE) handling with diff-streaming for efficient real-time updates. \submit.ts\ and \predict.ts\ provide the core asynchronous iteration logic for API calls, while \upload\_files.ts\, \handle\_blob.ts\, and \filesize.ts\ improve file upload and size formatting. Additional utilities like \duplicate.ts\ enable programmatic space duplication, \post\_data.ts\ standardizes API requests, and \view\_api.ts\ fetches API documentation.
client/js/src/utils · high confidence
New concurrency demo applications added
Two new demo applications have been added to illustrate Gradio's concurrency handling: one using a queue-based approach and another demonstrating thread limits by setting max\_threads=41. Both demos feature a simple interface with a text input, a button, and a text output, where clicking the button triggers a 5-second delay before returning a greeting.
_demo/concurrency\_with\queue · high confidence
New custom component build and development tooling in js/preview
The js/preview package now includes a complete toolchain for building and developing Gradio custom components. This adds a build system powered by Vite and Svelte, allowing custom components to define their own Vite plugins, Svelte preprocessors, build targets, and dependency optimization settings via a \gradio.config.js\ file. The new dev mode provides a live-reload server for custom components, while the build mode compiles them into optimized ES modules. The tooling also handles Windows path compatibility, integrates with the Python backend via a new \examine.py\ script, and includes a vendored ESM-compatible deepmerge utility to support configuration merging.
js/preview · high confidence
New dataset component preview demo
A new demo script has been added to showcase the gr.Dataset component across various data types, including audio, images, video, files, 3D models, and standard UI elements like checkboxes, dropdowns, and textboxes.
demo/dataset · high confidence
New demo app for loading OpenAPI specs via Gradio
A new demo application has been added at demo/load\_openapi\_spec that demonstrates how to create a Gradio interface from an OpenAPI specification. The app loads the Petstore v3 OpenAPI spec and exposes GET and POST operations for pet-related paths, launching with MCP server support enabled.
_demo/load\_openapi\spec · high confidence
New demo application for Gradio 4.0
A new demo application has been added at demo/hello\_world\_4/run.py, demonstrating a Gradio 4.0 interface that accepts a name and an intensity slider to repeat a greeting message.
_demo/hello\_world\4 · high confidence
New demo applications for Gradio 6.0 features
This update adds several new demo applications to the repository, showcasing capabilities in Gradio 6.0. These include a chatbot demo utilizing the new \reasoning\_tags\ parameter to collapse thinking blocks, multiple demos demonstrating the new \@gr.mcp.tool\ and \@gr.mcp.resource\ decorators for Model Context Protocol integration, and various examples for the \gr.HTML\ component including custom star ratings, event handling, and template-based rendering. Additional demos illustrate pending input handling for file uploads, the \show\_progress\_on\ parameter for progress indicators, and the \queue=False\ option for render functions.
(repo-wide) · high confidence
New demo applications for the \`gr.on\` listener decorator
Added two new demo applications (\on\_listener\_decorator\ and \on\_listener\_live\) that showcase the usage of the \gr.on\ decorator for handling component events. The first demo illustrates binding a function to multiple triggers (textbox submission and button click) with input/output mapping, while the second demonstrates a live-updating calculation across multiple sliders using the decorator.
_demo/on\_listener\_decorator, demo/on\_listener\live · high confidence
New demo apps for input-only and output-only interfaces
Added two new demo applications in the \demo\ directory that showcase Gradio's support for interfaces with only inputs or only outputs. The \fake\_gan\_no\_input\ demo demonstrates an output-only interface where the function generates images without requiring user input, while the \save\_file\_no\_output\ demo illustrates an input-only interface that saves an uploaded image to disk without returning any output to the user.
_demo/fake\_gan\_no\input · high confidence
New demo for batched image generation with Diffusers and Gradio
A new demo application has been added at demo/diffusers\_with\_batching/run.py that showcases batched inference using the Diffusers library. The application loads the CompVis/ldm-text2im-large-256 model, optionally moves it to a GPU if available, and exposes a Gradio interface that accepts text prompts and returns generated images. It is configured to process up to 4 prompts simultaneously (max\_batch\_size=4) to optimize resource usage, and includes an API endpoint named 'predict'.
_demo/diffusers\_with\batching · high confidence
New demo for comparing vision-language models on screenshot-to-HTML tasks
Added a new demo in \demo/workflow\_vlm\_html\_comparison\ that provides a side-by-side visual comparison of two vision-language models (thinkingmachines/Inkling and moonshotai/Kimi-K2.7-Code). The demo takes a screenshot and a text instruction, generates HTML from each model, and uses Playwright to render screenshots of the resulting webpages for direct visual evaluation against the original input.
_demo/workflow\_vlm\_html\comparison · high confidence
New demo for filtering dataframe records by gender
Added a new demo application in the \demo/filter\_records\ directory that demonstrates how to filter a Gradio Dataframe based on a user-selected gender value. The interface accepts a dataframe with name, age, and gender columns, along with a dropdown for selecting 'M', 'F', or 'O', and returns the filtered rows.
_demo/filter\records · high confidence
New demo for flagging data points with Gradio Blocks
Added a new demo script (demo/blocks\_flag/run.py) that demonstrates how to use the CSVLogger to flag specific data points within a Gradio Blocks interface. The example implements a sepia image filter where users can adjust the strength via a slider, and includes a 'Flag' button that allows users to log the current input image, strength value, and output image to a CSV file for later review.
_demo/blocks\flag · high confidence
New demo for generating playable video files
Added a new demo application in the \demo/white\_noise\_vid\_not\_playable\ directory that generates a short, random video file using OpenCV and displays it via Gradio. The demo includes functionality to create an MP4 video from random pixel data and allows users to download the generated file, addressing previous issues where video outputs were not playable.
_demo/white\_noise\_vid\_not\playable · high confidence
New demo for handling remote image URLs
Added a new demo application in the \demo/image\_remote\_url\ directory that demonstrates how to use Gradio to accept an image input and return both a loopback of that image and a static image served from a remote URL. The demo registers local image files as static paths and uses a simple function to process the input, providing a practical example for users integrating remote image handling into their Gradio interfaces.
_demo/image\_remote\url · high confidence
New demo for inspecting request headers and client information
A new demo application has been added at demo/request\_ip\_headers that allows users to see how Gradio exposes request metadata. By submitting text, users can view the client's IP address, user-agent string, and the full set of HTTP headers in the JSON response, demonstrating the use of the gr.Request object within a Gradio Interface.
_demo/request\_ip\headers · high confidence
New demo for loading and using an image classifier interface
A new demo application has been added at \demo/image\_classifier\_interface\_load\ that demonstrates loading a pre-trained image classification model (Google ViT) using Gradio's \gr.load\ function. The demo showcases two main capabilities: first, loading the model directly with example images for quick testing, and second, wrapping the loaded classifier within a custom Gradio Interface that combines image input with text input, allowing users to see how a loaded model can be integrated into more complex, multi-input workflows. This provides a practical example for users looking to leverage existing Hugging Face models within their own Gradio applications.
_demo/image\_classifier\_interface\load · high confidence
New demo for loading models with a Hugging Face token
A new demo application has been added at \demo/load\_model\_with\_token\ that demonstrates how to load the \meta-llama/Meta-Llama-3-8B-Instruct\ model from the Hugging Face Hub using a user's authentication token. The demo utilizes Gradio's \gr.load\ function with \accept\_token=True\ to handle the required PRO token access, providing a concrete example for users needing to authenticate when accessing gated models.
_demo/load\_model\_with\token · high confidence
New demo for managing interface state with history tracking
A new demo located at \demo/interface\_state/run.py\ has been added to illustrate how to manage and display interface state. This example demonstrates capturing user input and maintaining a history of previous messages, returning both the current message and the reversed history in a JSON output while updating the internal state.
_demo/interface\state · high confidence
New demo for side-by-side comparison of Krea-2-Turbo and FLUX.1-dev image models
A new demo workflow has been added that allows users to compare two text-to-image models, Krea-2-Turbo and FLUX.1-dev, side-by-side. The workflow takes a single text prompt and fans it out to both models, displaying the resulting images in a Gradio interface for direct visual comparison.
_demo/workflow\_image\_generator\comparison · high confidence
New demo for speech-to-text and sentiment analysis
A new demo application has been added at demo/blocks\_speech\_text\_sentiment that demonstrates a two-step pipeline: first, it uses the Hugging Face \transformers\ library to transcribe audio input into text via the \facebook/wav2vec2-base-960h\ model, and second, it classifies the sentiment of that text. Users can interact with the demo by uploading an audio file, recognizing the speech, and then classifying the sentiment of the resulting text.
_demo/blocks\_speech\_text\sentiment · high confidence
New demo for streaming audio output
Added a new demo application at demo/stream\_audio\_out that demonstrates two methods for streaming audio output in Gradio: streaming as temporary files and streaming as raw bytes. The demo allows users to upload an input audio file, select an output format (WAV or MP3) for the file-based streaming method, and observe real-time audio playback via streaming components.
_demo/stream\_audio\out · high confidence
New demo for sub-block rendering with image generation examples
A new demo application has been added at demo/sub\_block\_render that showcases Gradio's sub-block rendering capabilities. The app features a text input for prompts, a guidance scale slider, and a gallery for displaying generated images. It includes pre-loaded examples (such as 'A serious capybara at work') and uses local image assets (cheetah.jpg, frog.jpg) as fallbacks when specific text inputs are provided. The demo is configured with concurrency limits and example caching to demonstrate efficient handling of image generation tasks.
_demo/sub\_block\render · high confidence
New demo for text diffing with highlighted output
A new demo application has been added at demo/diff\_texts/run.py that allows users to compare two text inputs and visualize the differences. The interface uses gr.HighlightedText to display the diff results, with added text highlighted in red and removed text in green, and includes a legend to explain the color coding.
_demo/diff\texts · high confidence
New demo illustrating input vs. change event behavior
A new demo application (\demo/change\_vs\_input\) has been added to help users understand the difference between input and change events across Gradio components. The demo includes textboxes, numbers, sliders, checkboxes, radio buttons, dropdowns, color pickers, code blocks, dataframes, images, audio, and video components, demonstrating how \.input()\ and \.change()\ events trigger differently for each type.
_demo/change\_vs\input · high confidence
New demo server app with MCP tool support
A new demo application has been added at demo/server\_app/run.py that exposes calculator functions (add, multiply) as both API endpoints and MCP tools. The app includes a simple HTML interface for interacting with these tools and launches with MCP server mode enabled.
_demo/server\app · high confidence
New demo showcasing ChatInterface with random responses
A new demo application has been added at demo/chatinterface\_random\_response that demonstrates the ChatInterface component. The demo implements a simple bot that returns a random 'Yes' or 'No' response to user input, configured with autofocus disabled and an API endpoint named 'chat'.
_demo/chatinterface\_random\response · high confidence
New demo showcasing ClearButton with visibility toggling
A new demo application has been added to the \demo/clear\_components\ directory that demonstrates the \gr.ClearButton\ component alongside a wide variety of other Gradio inputs (such as Textbox, Slider, Image, and Gallery). The demo specifically illustrates how the \ClearButton\ and the associated components can be dynamically hidden and revealed using the \visible\ property, allowing users to see how clearing state interacts with component visibility in a live interface.
_demo/clear\components · high confidence
New demo showcasing Gradio component layout and interaction
A new demo application has been added to the big\_complex\_demo directory, providing a comprehensive example of Gradio's UI capabilities. The application organizes various components into tabs, demonstrating text inputs, media handling (images, audio, video), data visualization (dataframes, plots), and layout structures like accordions and rows. This serves as a reference for building complex, multi-tab interfaces with diverse input and output types.
_demo/big\_complex\demo · high confidence
New demo showcasing State management and custom CSS in Blocks
A new demo application (\demo/blocks\_simple\_squares/run.py\) has been added to illustrate the use of \gr.State\ for maintaining variable state across interactions, specifically tracking a counter and a history of squared values in a JSON table. The demo also demonstrates applying custom CSS styles to specific UI elements via the \elem\_classes\ and \elem\_id\ parameters, as well as passing inline CSS to the \launch\ method to style the button.
_demo/blocks\_simple\squares · high confidence
New demo showcasing Timer component and function value updates
A new demo application has been added to the function\_values directory that demonstrates the Gradio Timer component. This interactive example allows users to control the update frequency of random country selections via Start/Stop buttons and a slider, while also illustrating how to pass inputs to functions that update JSON outputs.
_demo/function\values · high confidence
New demo showcasing multimodal chatbot with diverse media responses
A new demo application (\demo/chatbot\_core\_components\_simple\) has been added that illustrates a chatbot interface capable of handling multimodal input (text, images, audio, video) and generating varied response types. Users can select from options such as text, image, gallery, video, audio, HTML, and 3D models (Model3D) to see how the chatbot renders different content types within the conversation history.
_demo/chatbot\_core\_components\simple · high confidence
New demo showcasing page load events
A new demo application has been added at demo/blocks\_page\_load that demonstrates the use of the \demo.load\ event handler. This example illustrates how to execute a function (printing a welcome message based on a name input) automatically when the page finishes loading, rather than in response to a specific user interaction like a button click.
_demo/blocks\_page\load · high confidence
New demo showcasing shared props and component validation
Added a new demo script in the shared\_props directory that demonstrates Gradio's shared props feature and input validation. The demo includes a layout with panel and compact columns, padded and unpadded HTML elements, shared JSON and Plot components, scaled tabs, a dataset with image samples, and a text validation workflow using a custom validator function.
_demo/shared\props · high confidence
New demo showcasing system prompt and additional inputs in ChatInterface
A new demo application has been added at demo/chatinterface\_system\_prompt that demonstrates how to use the additional\_inputs parameter in gr.ChatInterface. The demo allows users to provide a custom system prompt via a text box and control the response length via a slider, illustrating how extra inputs can be integrated into the chat interface workflow.
_demo/chatinterface\_system\prompt · high confidence
New demo showcasing the Sidebar component with configurable position
A new demo application has been added to the blocks\_sidebar directory that demonstrates the gr.Sidebar component. The example features a pet name generator where the sidebar is explicitly positioned on the left side, containing controls for selecting animal type and personality, while the main content area displays the generated output.
_demo/blocks\sidebar · high confidence
New demo utilities and state management example
Users can now use the new \random\_demos.py\ script to randomly launch a specified number of demos for quick inspection, with logic to skip large or special-case demos. Additionally, a new \simple\_state\ demo has been added to demonstrate how to manage application state using Gradio's \State\ component, specifically showing how to accumulate items in a shopping cart. The demo package has also been renamed from \gradiome\ to \demo\.
demo · high confidence
New demo workflow for marketing image creation
A new demo workflow has been added to the \demo/workflow\ directory, providing a 'Marketing Image Creator' application. This demo allows users to upload an image which is then captioned using the \ovi054/image-to-prompt\ model, followed by the generation of a marketing-style image using the \multimodalart/FLUX.1-merged\ model. The workflow is defined in \workflow.json\ and can be launched via the \run.py\ script using Gradio.
demo/workflow · high confidence
New demo: Neural Instrument Cloning
A new demo application has been added at demo/blocks\_neural\_instrument\_coding that showcases a 'Neural Instrument Cloning' interface built with Gradio Blocks. The demo presents a UI with markdown explanations, audio examples, and a tabbed interface allowing users to interact with simulated models for Saxophone, Flute, and Trombone by adjusting pitch and loudness or uploading base audio files. It also includes a feature to demonstrate audio reconstruction/cloning and displays a timestamp upon loading.
_demo/blocks\_neural\_instrument\coding · high confidence
New demos demonstrating default image handling and file upload size limits
Added two new demo applications: \demo/image\_mod\_default\_image\ showcases how to set a default image for an interface using \get\_image()\, while \demo/upload\_file\_limit\_test\ demonstrates the \max\_file\_size\ parameter in \launch()\ by restricting uploads to 15kb and verifying the error modal behavior.
_demo/image\_mod\_default\image · high confidence
New demos demonstrating dynamic rendering and event handling
Added two new demo applications in the \demo/render\_merge\ and \demo/render\_split\ directories to showcase advanced \gr.render\ capabilities. The \render\_merge\ demo illustrates how to dynamically render components based on user input (a slider controlling textbox count), handle button clicks within those dynamic blocks, and integrate custom JavaScript event listeners on HTML elements. The \render\_split\ demo demonstrates conditional rendering and multiple trigger sources, showing how to switch between displaying text boxes or buttons based on a radio selection and input submission.
_demo/render\merge · high confidence
New demos demonstrating state and file resource cleanup
Added two new demo applications (\demo/state\_cleanup\ and \demo/unload\_event\_test\) that illustrate how to manage user-specific resources and clean up state when a session ends. The \state\_cleanup\ demo shows how to save generated images to a user-specific directory and delete them using \demo.unload\, while also utilizing the \delete\_callback\ on \gr.State\ to handle in-memory state cleanup. The \unload\_event\_test\ demo provides a focused example of triggering custom logic via the \demo.unload\ event and state deletion callbacks.
_demo/state\cleanup · high confidence
New demos for Parler-TTS streaming and video output
Added a Magic 8 Ball demo that uses Parler-TTS to generate streaming audio responses to voice questions, including a custom streamer for non-blocking playback, and a Video Streaming Out demo that processes input video frames in real-time with options to stream as MP4 or TS segments.
_demo/magic\_8\_ball, demo/stream\_video\out · high confidence
New demos for depth estimation and musical instrument identification
Added two new interactive demos to the platform. The depth estimation demo allows users to upload an image to predict its depth map and generate a 3D model (GLTF) using the DPT model and Open3D. The musical instrument identification demo enables users to upload audio files to identify instruments (such as piano, guitar, violin, etc.) using a pre-trained CNN model, displaying the top predictions and inference time.
_demo/depth\estimation · high confidence
New development and CI scripts for Gradio 5.0
This change introduces a comprehensive suite of new scripts to support the Gradio 5.0 development workflow and CI infrastructure. It adds benchmarking tools for API latency (\benchmark\_latency\_api.py\, \benchmark\_latency\_mcp.py\) and frontend performance (\compare\_frontend\_benchmarks.js\), as well as scripts for building the frontend (\build\_frontend.sh\, \build\_frontend.bat\) with offline asset support. The suite includes utilities for formatting and linting the backend and frontend using Ruff and pnpm, generating theme CSS, and managing workflow templates. Additionally, it provides scripts for copying demos, installing dependencies, and cleaning up old Spaces, establishing the operational tooling for the new version.
scripts · high confidence
New event-trigger demo for Gradio components
A new demo application has been added at demo/event\_trigger/run.py that demonstrates how to handle change, play, pause, stop, and end events across various Gradio components including Textbox, Video, Image, and File. The demo illustrates binding event listeners to detect value changes and media playback states, providing a practical example for users implementing similar event-driven interactions in their own applications.
_demo/event\trigger · high confidence
New fake\_diffusion demo showcasing iterative image generation
A new demo has been added to showcase iterative output capabilities. The fake\_diffusion application uses a Gradio Interface with a slider input to control the number of steps, yielding intermediate random images during processing before displaying a final solid-color image, allowing users to see the output update progressively.
_demo/fake\diffusion · high confidence
New fraud detector demo with interactive category selection
Added a new demo application in the fraud\_detector location that allows users to simulate fraud detection by selecting specific transaction categories (retail, food, other) via a checkbox group and adjusting a sensitivity slider. The interface accepts a CSV file of transaction data, filters it based on the selected categories, and outputs the filtered dataframe alongside a calculated fraud probability label.
_demo/fraud\detector · high confidence
New gr.Navbar component for multipage apps
The demo now showcases the new gr.Navbar component, which allows users to customize navigation in multipage applications. The example demonstrates setting the main page name, toggling visibility via buttons, and navigating to a secondary 'Settings' route.
_demo/navbar\customization · high confidence
New gr.on listener method for event handling
A new \gr.on\ listener method has been introduced, allowing users to attach event handlers to multiple triggers (such as button clicks or text submissions) in a single declaration. The \demo/on\_listener\_basic\ and \demo/on\_listener\_test\ demos demonstrate this capability, showing how \gr.on\ can map inputs and outputs for a primary function and chain subsequent actions (like clearing fields) using \.then()\, while also exposing event metadata via \gr.EventData\.
_demo/on\_listener\basic · high confidence
New i18n demo showcasing runtime language switching
A new demo application (\demo/i18n/run.py\) has been added to illustrate Gradio's internationalization capabilities. This example demonstrates how to initialize an \gr.I18n\ instance with translations for English, Spanish, French, and German, and apply them to UI elements like labels, buttons, and radio choices. It specifically highlights that display names in choices are translated while values remain constant, and shows how to pass the i18n configuration to the \demo.launch()\ function to enable automatic language detection or manual switching.
demo/i18n · high confidence
New image classification demos added
Two new demo applications have been added to the \demo/image\_classifier\ and \demo/image\_classifier\_2\ directories. The first demo uses TensorFlow's MobileNetV2 model to classify images, while the second utilizes PyTorch's ResNet18 model. Both demos provide a Gradio interface for users to upload images and receive classification predictions.
_demo/image\classifier · high confidence
New image editing demos using Gradio components
Added two new demo applications: an inpainting demo that uses the ImageEditor component to average colors in selected mask areas, and a sketchpad demo that uses the Sketchpad component to calculate the percentage of pixels selected in a drawing.
_demo/image\_editor\_inpainting, demo/image\_editor\sketchpad · high confidence
New image modification demo with dynamic example updates
A new demo application has been added at demo/image\_mod/run.py that demonstrates image rotation functionality. The demo allows users to upload or select images from predefined examples and rotate them by 45 degrees. A key feature is the ability to dynamically update the available example images via a button click, showcasing the updated capability to modify gr.Examples datasets at runtime.
_demo/image\mod · high confidence
New image segmentation demo using click-based flood fill
Added a new demo application in \demo/image\_selections\ that demonstrates image segmentation via a flood-fill algorithm. Users can upload an input image and adjust a tolerance slider to control color similarity; clicking on the image triggers a selection that highlights the connected segment of similar-colored pixels in the output view.
_demo/image\selections · high confidence
New image segmentation demo with annotated output
A new demo has been added to the image\_segmentation location that allows users to upload an image and generate random bounding boxes and circular segments. The demo uses Gradio's AnnotatedImage component to display the output, supporting custom color mappings for specific labels like 'banana' and 'carrot'. Users can adjust the number of boxes and segments via sliders, click an 'Identify Sections' button to generate the annotations, and select specific sections in the output to see their labels in a text box.
_demo/image\segmentation · high confidence
New interactive dashboard demo for Hugging Face library metrics
Added a new demo in the dashboard location that allows users to visualize metrics for popular Python libraries (such as transformers, diffusers, and gradio) by fetching data from the Hugging Face Hub. The demo provides interactive controls to select specific libraries and toggle between different metric views, including pip install counts (cumulated or daily), GitHub stars, and issue/PR activity, with options to filter out organization members or view week-over-week changes.
demo/dashboard · high confidence
New interactive demo with adjustable greeting intensity
A new demo application has been added at demo/hello\_world\_2 that allows users to input a name and an intensity value via a slider (range 1–10, step 1) to repeat the greeting message. The interface exposes a 'predict' API endpoint and displays the resulting repeated greeting in a multi-line text box.
_demo/hello\_world\2 · high confidence
New interactive scatter plot demo with time-series and food rating data
A new demo application has been added that showcases the Gradio ScatterPlot component using two distinct datasets: simulated temperature/humidity sensor data and food rating information. The interface allows users to interactively filter the time-series data by selecting start and end dates, grouping intervals (such as 30m, 1h, or 1d), and choosing aggregation methods (sum, mean, median, min, max). It also demonstrates scatter plots for food ratings, including options to color-code by wait time or cuisine type, providing a practical example of how to build dynamic, data-driven visualizations.
_demo/scatter\_plot\demo · high confidence
New interactive todo list demo with client-side updates
A new demo application (\demo/todo\_list\_js/run.py\) has been added that demonstrates a simple todo list where all actions, such as editing tasks, marking them complete, and freezing or unfreezing the list, are performed on the client side using JavaScript. This showcases the capability to run functions that solely update component properties in the frontend by setting \js=True\.
_demo/todo\_list\js · high confidence
New kinematics trajectory demo
A new demo application has been added to visualize projectile motion kinematics. Users can adjust initial speed and launch angle using sliders, and clicking 'Run' generates a line plot showing the resulting trajectory based on standard physics equations.
_demo/blocks\kinematics · high confidence
New live dashboard demo showcasing real-time updates and plot interaction
A new demo application has been added to the live\_dashboard directory, demonstrating how to build a live interactive dashboard using Gradio. The application features a real-time clock that refreshes every second and a sine wave plot that updates every half second, controlled by a slider to adjust the wave's period. It also includes interactive features such as brushing (selecting a range on the plot to zoom in) and double-clicking to reset the view, illustrating the use of the 'every' keyword in event handlers and the LinePlot component.
_demo/live\dashboard · high confidence
New matrix transpose demo with fullscreen support
A new demo application has been added at demo/matrix\_transpose that allows users to transpose matrices via a Gradio Interface. The demo features a gr.Dataframe input configured with a new 'fullscreen' button, enabling users to expand the data grid for better visibility when working with larger matrices.
_demo/matrix\transpose · high confidence
New mock speech diarization demo using gr.Dialogue
A new demo application has been added at demo/dialogue\_mock\_diarization that demonstrates mock speech diarization. The application accepts audio input via a microphone and outputs a dialogue formatted with speaker tags using the gr.Dialogue component, simulating a conversation between two speakers.
_demo/dialogue\_mock\diarization · high confidence
New multi-component demo showcasing 10 interactive tabs
A new demo application has been added at demo/many\_tabs/run.py that illustrates Gradio's capabilities across ten distinct tabs. Users can interact with various components including text processing, 3D model viewing, image editing, audio recording/uploading, file uploads, and an interactive dataframe with row manipulation. This serves as a comprehensive example of building complex, multi-tab interfaces with Gradio.
_demo/many\tabs · high confidence
New multimodal chatbot demo with example messages
A new demo script has been added to the chatbot examples directory that showcases a Gradio-based chat interface supporting multimodal inputs (text and files). The demo includes pre-configured example messages that users can select to quickly test the chatbot with various combinations of text, images, and audio files, along with like/dislike feedback tracking.
_demo/chatbot\examples · high confidence
New multimodal chatbot demo with file upload and streaming
Added a new demo application (\demo/chatbot\_multimodal\) that showcases a chatbot interface capable of handling multimodal inputs, including text, images, audio, and video via the \MultimodalTextbox\ component. The demo demonstrates key features such as streaming text responses, user feedback through like/dislike buttons, and the ability to upload multiple files simultaneously. A separate minimal demo (\demo/multimodaltextbox\_component\) was also added to illustrate the basic usage of the \MultimodalTextbox\ component.
_demo/chatbot\multimodal · high confidence
New plot interaction demos: filtering, selection, and zooming
Added four new demo applications in the plot guide that demonstrate interactive capabilities of Gradio plots. Users can now see examples of filtering data via dropdowns and sliders (plot\_guide\_filters\_events), selecting regions on a line plot to compute aggregates (plot\_guide\_selection), resetting zoom levels via double-click (plot\_guide\_zoom), and synchronizing zoom/selection across multiple plot types (plot\_guide\_zoom\_sync).
(repo-wide) · high confidence
New rate-limiting demo application
Added a new demo application in demo/rate\_limit/run.py that demonstrates rate limiting based on authentication status. The app allows users to test rate limits by clicking a button, showing different limits for authenticated users (30 clicks per minute) versus unauthenticated users (3 clicks per minute based on IP address).
_demo/rate\limit · high confidence
New render decorator demos for dynamic UI merging and splitting
Added two new demo applications illustrating the \@gr.render\ decorator's capabilities. The \render\_merge\_simple\ demo shows how to dynamically generate UI components based on a counter and merge their values into a single output, while \render\_split\_simple\ demonstrates splitting input text into individual character components for separate display.
_demo/render\_merge\_simple, demo/render\_split\simple · high confidence
New reverse audio demo with custom waveform styling
A new demo application has been added at demo/reverse\_audio that allows users to record audio via microphone and reverse it. The interface uses a custom Audio component configuration that disables the recording waveform display and applies specific blue color schemes to the waveform and progress indicators.
_demo/reverse\audio · high confidence
New scatter plot demo with multi-dataset support
A new demo application for the scatter plot component has been added, allowing users to switch between the Iris and Cars datasets via a dropdown. The example demonstrates configuring the plot with specific x/y axes, color encoding, titles, captions, and custom tooltips that display additional data columns.
_demo/scatter\plot · high confidence
New sentence builder demo with enhanced input context
A new demo application has been added at demo/sentence\_builder/run.py that constructs sentences based on user inputs for quantity, animal, countries, location, activities, and time of day. The interface utilizes various input components including a slider, dropdowns, checkbox groups, and radio buttons, with multi-select enabled for the activity dropdown. Each input field now includes an 'info' parameter to provide additional context and guidance to users, such as specifying valid ranges or explaining the purpose of each selection.
_demo/sentence\builder · high confidence
New sine curve demo with periodic auto-updating plot
A new demo application has been added at demo/sine\_curve/run.py that visualizes a sine wave using Plotly. The interface includes a slider to adjust the wave's period and a timer that automatically refreshes the plot every second, allowing users to observe the continuous evolution of the curve.
_demo/sine\curve · high confidence
New sound alert demo for Gradio
A new demo application has been added at demo/sound\_alert/run.py that demonstrates how to play a sound alert when a prediction is complete. The demo uses Gradio to create a simple interface where entering a name triggers a greeting, and upon completion, a beep sound is played via JavaScript.
_demo/sound\alert · high confidence
New speaker verification and text generation demos added
Added two new interactive demos to the website. The 'same-person-or-different' demo allows users to record or upload two audio samples to determine if they are from the same speaker using the Microsoft UniSpeech-SAT model, requiring ffmpeg for audio processing. The 'text\_generation' demo provides a simple interface for generating text using the GPT-2 model.
demo/same-person-or-different · high confidence
New temperature conversion demo added
A new demo application (demo/hello\_world\_3) has been added that demonstrates an Interface with multiple inputs (text, checkbox, and slider) and outputs (text and number), specifically performing a Fahrenheit-to-Celsius temperature conversion alongside a greeting.
_demo/hello\_world\3 · high confidence
New text autocomplete and speech recognition demos
Added new demo applications for text autocomplete and automatic speech recognition. The autocomplete demo uses the Microsoft Phi-1.5 model to provide text completion within a single textbox interface, while the speech recognition demo utilizes OpenAI's Whisper-large-v3 model to transcribe audio input from a microphone. Both demos are implemented using Gradio and require an Hugging Face token via the HF\_TOKEN environment variable to manage API rate limits.
demo/autocomplete · high confidence
New theme customization demos added
Added two new demo applications in the theme\_extended\_step\_3 and theme\_extended\_step\_4 directories that demonstrate how to apply custom themes to Gradio interfaces. The step\_3 demo shows how to configure a default theme with specific fonts (Inconsolata, Arial), while the step\_4 demo illustrates how to create a custom theme object with specific color overrides (loader and slider colors) and apply it to the app.
_demo/theme\_extended\_step\_3, demo/theme\_extended\_step\4 · high confidence
New utility modules for HLS playback, URL resolution, and component utilities
The \js/utils\ package now includes dedicated modules for handling HLS video streaming, URL resolution, and shared component logic. The new \hls.ts\ module provides robust HLS stream management with automatic stall detection and recovery, ensuring smoother video playback. The \url.ts\ module introduces \resolve\_current\_origin\_url\ to correctly handle proxy ports and origins in frontend asset URLs, fixing issues with custom components in SSR mode and embedded pages. Additionally, \color.ts\ adds a utility for cycling through theme colors, and \types.ts\ defines the \CustomButton\ interface used for custom component buttons.
js/utils · high confidence
New validator demo showcasing input validation in Gradio ChatInterface
A new demo application has been added at demo/validator\_chatinterface/run.py that demonstrates how to use the validator parameter in Gradio's ChatInterface. The example implements a simple validation function that rejects inputs containing the word 'error' and displays a custom error message, allowing users to see how input validation integrates with chat-based interfaces.
_demo/validator\chatinterface · high confidence
New walkthrough demo applications
Added two new demo applications in the \demo/walkthrough\ and \demo/walkthrough\_many\ directories that showcase the \gr.Walkthrough\ and \gr.Step\ components. The first demo illustrates a simple three-step flow (Image, Prompt, Result) with navigation buttons, while the second demonstrates a multi-step (eight-step) process with sequential navigation, allowing users to see how the walkthrough UI handles state transitions and step progression.
_demo/llm\_hyperbolic, demo/llm\_openai, demo/llm\_sambanova, demo/skip, demo/streaming\_simple, demo/walkthrough, demo/walkthrough\many · high confidence
New webcam demo for simultaneous image and video capture
A new demo application has been added at demo/webcam/run.py that allows users to capture both an image and a video stream simultaneously from their webcam. The interface uses Gradio to present two input sources (image and video) from the webcam and outputs the captured data, providing a simple way to test or demonstrate dual-stream webcam functionality.
demo/webcam · high confidence
New webcam streaming demos for image filtering and YOLOv10 object detection
Added three new demo applications that enable real-time webcam streaming. The \streaming\_filter\ demo allows users to apply real-time image transformations (cartoon, edges, or flip) to a webcam feed using OpenCV. The \streaming\_filter\_unified\ demo provides a similar filtering experience but streams the processed output back into the same input component for a unified view. The \yolov10\_webcam\_stream\ demo integrates the YOLOv10 object detection model (via ONNX Runtime) with Gradio's WebRTC support, allowing users to see real-time object detection results on their webcam feed with a configurable confidence threshold.
_demo/streaming\_filter, demo/streaming\_filter\_unified, demo/yolov10\_webcam\stream · high confidence
New workflow demo exposing a combined API endpoint
A new demo in the \workflow\_api\ directory introduces a 'Text Tools' workflow that chains a local text-reversal function with remote AI services (Llama 3.1 for text generation and FLUX.1 for image generation). This setup allows users to access all three outputs—reversed text, generated text, and an image—through a single API endpoint, simplifying integration for clients using the Gradio client.
_demo/workflow\api · high confidence
Python client release notes and core module initialization
The \gradio\client\ package now includes a comprehensive changelog (CHANGELOG.md) documenting the history of the Python client, and initializes the core module structure with \\\init\\_.py\, \data\_classes.py\, \documentation.py\, \exceptions.py\, \snippet.py\, \types.json\, and \utils.py\. This establishes the foundational types, utilities, and documentation generation logic for the client, while the changelog records past fixes and features such as heartbeat leak prevention, OAuth token support, and file URL sanitization.
_client/python/gradio\client · high confidence
Reorganized and expanded Gradio documentation guides
The documentation has been restructured into a logical, sequential learning path. A new Quickstart guide now covers installation, building your first demo, and sharing. The Interface section has been expanded to include dedicated guides for examples, flagging, state management, and reactive interfaces, while also documenting the four kinds of Interface demos (standard, output-only, input-only, and unified). The Blocks section now provides deeper coverage of event listeners, layout control (including the new Sidebar and Walkthrough components), and dynamic apps using the render decorator.
guides · high confidence
Static llms.txt route for LLM consumption
The website now serves a static \llms.txt\ route that allows AI agents and LLMs to fetch documentation and guides in Markdown format. The server-side hook detects requests from known AI user-agents (such as GPTBot, Claude, and Perplexity) or requests for \text/markdown\ content, and returns the corresponding documentation or guide content as plain Markdown with a \noindex\ header, enabling better integration with AI tools.
_js/\website · high confidence
Support for dictionary-style inputs in calculator demo
The calculator demo now allows users to submit inputs as a dictionary, demonstrated by the subtraction operation which accepts a combined input object rather than separate arguments. This change enables more flexible data passing patterns within the Gradio interface.
_demo/calculator\_list\_and\dict · high confidence
Support for prefilling chat history in ChatInterface
The demo for the ChatInterface component now demonstrates how to programmatically set initial chat history using the new \chatbot\_value\ property. By linking a radio button's change event to \chat.chatbot\_value\, users can now inject predefined conversation turns (such as greetings or complaints) into the chat interface before the user starts typing, enabling richer demo scenarios and pre-filled contexts.
_demo/chatinterface\prefill · high confidence
Tab component supports render\_children parameter
The Tab component now accepts a \render\_children\ parameter, allowing users to control whether a tab's content is rendered in the DOM even when the tab is not active. This enables scenarios where hidden tab content needs to be pre-rendered (e.g., for background processing or state preservation) without being visible to the user, as demonstrated by the ability to interact with elements inside a tab that is not currently selected.
_demo/tab\_render\children · high confidence
Video watermarking demo with position control
A new demo application has been added to the video\_watermark location that demonstrates how to apply a watermark to a video using the Video component. Users can upload a video and a watermark image, then select the watermark's position (top-left, top-right, bottom-left, or bottom-right) via a dropdown, and the demo generates the watermarked video output.
_demo/video\watermark · high confidence
Website worker now redirects LLM crawlers to markdown API endpoints
The Gradio website now includes a Cloudflare Worker that detects requests from AI crawlers (such as ChatGPT, Claude, and Google-Extended) via User-Agent and Accept headers. When an LLM crawler requests a documentation or guide page, the worker automatically redirects the request to a dedicated markdown API endpoint, ensuring that AI models receive clean, parseable text content instead of HTML.
js · high confidence
gr.HTML gains advanced templating, custom events, and server function support
The gr.HTML component has been significantly enhanced to support dynamic content and interactivity. Users can now define custom HTML structures using \html\_template\ and \css\_template\ with variable substitution (e.g., \${value}\, \${fontSize}\), allowing for dynamic styling and content rendering. The component supports custom JavaScript execution via \js\_on\_load\, enabling the dispatch of custom events (e.g., \trigger('submit')\) that can be handled by other Gradio components. Additionally, gr.HTML can now execute Python server functions directly from the frontend, upload files, and use a \watch\ API to react to backend prop changes. These changes are demonstrated in the new \demo/super\_html\ and related demo files, which showcase templating, custom event handling, server function integration, and file uploads.
_demo/super\html · high confidence
Removals
Removed Django project scaffolding files
The Django project configuration files (settings, URLs, and WSGI entry point) have been deleted from the gradiome directory. This removes the default Django application structure, including database configuration, middleware, and URL routing, effectively stripping the project of its previous web framework setup.
gradiome · high confidence
Behavioural changes
20 commits (5 fixes) modifying .changeset
A change to existing behaviour in .changeset — 20 commits (5 fixs), 5 files: “Lite version (\#7647)”; “Fix changesets action (\#4998)”; “bump client version (\#4185)”; and 17 more (refs \#7647, \#4998, \#4185, \#3574, \#5514, …).
.changeset · medium confidence · unverified
2730 commits (696 fixes) modifying gradio
A change to existing behaviour in gradio — 2730 commits (696 fixs), 248 files: “tabbed-interface-rewritten (\#958)”; “samples”; “chore: update versions (\#10876)”; and 2638 more (refs \#958, \#10876, \#13811, \#11963, \#11945, …).
gradio · medium confidence · unverified
Centralized configuration for frontend tooling and testing
The project now centralizes its frontend configuration files into the \.config\ directory. This change introduces dedicated configuration files for Prettier (\.prettierrc.json\, \.prettierignore\), ESLint (\eslint.config.js\), PostCSS and Tailwind (\postcss.config.cjs\, \tailwind.config.cjs\), Svelte (\svelte.config.js\), and testing infrastructure (\playwright.config.js\, \vitest.config.ts\, \setup\_vite\_tests.ts\). Additionally, a new \demos.json\ file explicitly lists the demo applications to be included, and a build hook (\pycompile-lite-wheel.py\) is added to handle Pyodide compilation for the Gradio Lite wheel. This consolidation standardizes formatting, linting, and testing behaviors across the codebase.
.config · high confidence
ChatInterface example caching modes and multimodal support
The demo/test\_chatinterface\_examples directory now includes specific test cases demonstrating the new caching behaviors and multimodal capabilities of gr.ChatInterface. Users can see examples of eager caching (cache\_mode="eager"), lazy caching (cache\_mode="lazy"), and multimodal message handling (multimodal=True), alongside the standard non-caching configuration, illustrating how to configure example pre-computation and input types.
_demo/test\_chatinterface\examples · high confidence
Core frontend components migrated to Svelte 5
The core frontend application, including the main Blocks container, component mounting logic, and API documentation pages, has been rewritten using Svelte 5. This migration introduces Svelte 5 runes (such as $state, $derived, and $props) and the new component model, replacing the previous Svelte 3 implementation to improve performance and maintainability.
js/core · high confidence
Demo app supports dict-based return values and component visibility toggling
The demo application in demo/blocks\_form/run.py has been updated to demonstrate returning a dictionary from event handlers, allowing multiple components to be updated simultaneously. Specifically, the submit button click handler now returns a dict that toggles the visibility of the output column and the submit button, while also updating the diagnosis and patient summary text boxes. This change also includes a gr.Number component with defined minimum and maximum limits for the age input.
_demo/blocks\form · high confidence
Demo chatbot with tools now uses the Message API
The demo application in demo/chatbot\_with\_tools has been updated to use the new ChatMessage class for constructing chat history, replacing the previous format. This change demonstrates how to structure assistant responses with metadata (such as tool usage titles) and integrates the chatbot's like functionality using the new event data structure.
_demo/chatbot\_with\tools · high confidence
Hello Login demo now requires authentication
The hello\_login demo application now enforces login access. Users must provide the credentials 'admin' for both username and password to launch and interact with the demo interface.
_demo/hello\login · high confidence
Improved package build isolation and dependency patching
The build process for Svelte packages (@sveltejs/package) now operates on a filtered temporary copy of the source directory rather than the original input, excluding test files, stories, and configuration artifacts to prevent side effects and improve isolation. Additionally, patches were applied to @ffmpeg/util to explicitly declare it as an ES module, and to amuchina to fix a document reference leak in its DOM traversal logic by using the parent's owner document.
patches · high confidence
JS client now supports authenticated private Spaces and improved file handling
The JS client helpers have been refactored to support authentication for private Hugging Face Spaces, including a new \token\ option (with \hf\_token\ alias for backward compatibility) and proper credential handling for cross-origin embeds. File uploads now correctly preserve filenames and MIME types for \File\, \Blob\, and \Buffer\ objects, and the client can now resolve URLs for apps hosted on subpaths or with custom root paths. Additionally, space status checking has been improved to handle sleeping, building, and paused states with better error messages, and ZeroGPU handshake initialization has been added to support GPU-accelerated Spaces.
client/js/src/helpers · high confidence
Migrate js/atoms to Svelte 5 and introduce new UI components
The \js/atoms\ package has been rewritten using Svelte 5 runes (e.g., \$state\, \$derived\, \$effect\, \$props\), replacing the previous implementation. This migration introduces several new UI components: \Block\ (handling layout, fullscreen portal logic, and resizing), \BlockLabel\ (using semantic \\<label\>\ elements with RTL support), \BlockTitle\, \CustomButton\, \DownloadLink\ (with Colab-aware target handling), \Empty\, \FullscreenButton\, \IconButton\, \IconButtonWrapper\, \Info\, \ScrollFade\, \SelectSource\ (for media input selection), \ShareButton\, \Toolbar\, and \UploadText\ (with density-aware text display). Additionally, a new \inline-markdown\ utility and its tests have been added to safely render inline markdown for component info text.
js/atoms · high confidence
New theme system with CSS variables and Tailwind-based color tokens
The theme layer has been replaced with a new architecture that uses CSS custom properties (variables) for styling and a Tailwind-inspired color palette. This introduces a structured set of semantic tokens for colors (red, green, blue, etc. with 10-950 shades), spacing, and typography, alongside dedicated stylesheets for resets, global layout, and prose rendering. Users will see a consistent, variable-driven visual design across components, with improved support for wide monitors (up to 1920px) and better integration with external environments via CSS resets.
js/theme · high confidence
Redesigned file upload component with progress tracking and improved file type validation
The file upload interface has been redesigned to provide real-time upload progress updates via a streaming event source, allowing users to see the status of their uploads. The component now supports compound file extensions (e.g., .nii.gz) and handles file type validation more robustly, including case-insensitive matching and proper handling of iOS-specific file picker limitations. A new ModifyUpload component adds edit, undo, and download actions for uploaded files, while the UploadProgress component displays a visual progress bar and file name during uploads. Drag-and-drop functionality has been improved to ignore clicks on specific child elements and correctly handle directory uploads.
js/upload · high confidence
Renamed and relocated static file to calculator examples
The file previously located at gradiome/static/humans.txt has been renamed to log.csv and moved to the demo/calculator/examples directory. This change updates the file's location and format within the calculator examples area, likely to align with the new documentation structure for calculator examples.
demo/calculator/examples · low confidence
Skills directory restructured via symlink
The .claude/skills path is now a symbolic link pointing to ../.agents/skills, effectively moving the skills configuration to the .agents directory while maintaining the previous access path.
.claude · high confidence
Standardize icon library with Feather-style SVGs
The icon library in \js/icons\ has been rebuilt using a consistent, modern SVG design system. All icons now use a uniform 24x24 viewBox, \currentColor\ for styling, and a 1.5px stroke width with rounded caps and joins, replacing the previous mix of emoji-based, fixed-size, and varied-style assets. This ensures visual consistency across the application and improves rendering reliability in browsers like Safari.
js/icons · high confidence
Storybook configuration upgraded to support Svelte 5 and runtime language switching
The Storybook setup has been reconfigured to work with the Svelte 5 compiler and enable runtime locale switching for component previews. A new \GradioContext.svelte\ provider now initializes \svelte-i18n\ and mocks the Gradio root context, ensuring components render with correct translations. The \preview.ts\ file adds a \withI18n\ decorator that updates the locale based on Storybook globals, allowing users to switch between English, French, German, Spanish, and Arabic directly in the Storybook UI. The \main.ts\ configuration has been updated to use \@storybook/svelte-vite\, disable prebundling of Svelte libraries to support Svelte 5's TypeScript preprocessing, and include necessary theme and reset CSS files.
.storybook · high confidence
Webcam input resolution is constrained to 1024x1024
The ImageEditor demo now restricts the webcam video feed to a fixed 1024x1024 resolution, ensuring that captured images match the canvas size.
_demo/image\_editor\webcam · high confidence
Website documentation and demo assets are now generated as JSON
The website build process now generates static JSON files for changelogs, demos, documentation, and guides, replacing the previous method of serving these assets directly. This change introduces a new \generate\jsons\ module that reads source Markdown and Python files from the repository, processes them (including stripping type-ignore comments and converting guide syntax like \$code\\ and \$demo\_\ into HTML), and outputs structured JSON data for the frontend to consume.
_js/\_website/generate\jsons · high confidence
Fixes
Demo app demonstrates programmatic tab selection and select event handling
The demo/tabs/run.py file has been added to showcase specific tab behaviors, including programmatically selecting a tab via ID (e.g., using \gr.Tabs(selected="a3")\ or updating the \selected\ property via a button), handling the \select\ event on individual tabs to display the selected tab's value, and ensuring the \select\ event fires on the outer \gr.Tabs\ container when the active tab changes. It also includes logic to count tab selections using a server-side accumulator to handle concurrent dispatches.
demo/tabs · medium confidence
Fix Dropdown change event when allow\_custom\_value is true
The demo application for the Dropdown component with \allow\_custom\_value=True\ now correctly triggers the change event, ensuring that the output textbox updates with the selected or custom value as intended.
_demo/dropdown\_custom\value · medium confidence
Fix change events for hidden components
The demo application now correctly handles change events on components that are hidden (visible=False) or contained within hidden parent elements. This ensures that state updates and event triggers, such as those on the hidden JSON component or textboxes within invisible rows, function as expected rather than being ignored.
_demo/hidden\change · high confidence
Fix crash when streaming responses lack choices
The chatbot demo now handles cases where the model's streaming response does not include a \choices\ array, preventing a crash during generation. This ensures the chat interface remains stable even if the underlying inference client returns an empty or malformed response structure.
_demo/chatbot\_retry\_undo\like · high confidence
Fix infinite effect loop in tabs
Resolves an infinite effect loop that occurred when switching tabs, ensuring that the demo's dataframe population via the tab select event functions correctly without causing application hangs or excessive resource usage.
_demo/dataframe\_tab\select · high confidence
Fix interactivity of value-less components with no dependencies
The demo/blocks\_static/run.py file has been added to demonstrate a fix for interactivity issues in components that have no dependencies and no initial values. This change ensures that components like gr.Image, gr.Textbox, and gr.Number function correctly in this specific configuration within the static blocks demo.
_demo/blocks\static · medium confidence
Fix loading spinner issue in inactive tabs
The demo application now correctly handles the load event for components located in inactive tabs, preventing the loading spinner from appearing incorrectly when the page initializes. This ensures a smoother user experience by avoiding visual artifacts associated with events targeting components that are not currently visible.
_demo/chatbot\_load\event · high confidence
JS client now ships a real browser bundle and CommonJS entry
The @gradio/client package now correctly emits a minified browser bundle at dist/index.min.js (accessible via the documented CDN path) and a CommonJS entry at dist/index.cjs for Node.js environments. This resolves previous issues where the documented CDN path and require() calls were not working as expected, ensuring the client works reliably in both browser and Node.js contexts.
client/js · high confidence
Test coverage
Add comprehensive backend unit tests for Gradio components; Add test fixtures and support files for Python client tests; Added demo fixtures for HTML head script execution order; Demo app added to test visibility states and multi-yield column updates; Demo app for Accordion tab switching and visibility edge cases; Initial test suite for the JS client; New testing utilities for file interactions and Svelte component rendering.
Dependencies
Update gradio\_client to version 2.7.2
The Python \gradio\_client\ package has been updated to version 2.7.2, with its build configuration now sourced from the embedded \package.json\ metadata. The client's runtime dependencies have been updated to require \huggingface\_hub\ version 1.16.0 or higher (below 3.0), and the test suite now relies on \pytest\ 9.1.1 and \ty\ 0.0.2.
(dependencies) · high confidence
Housekeeping
Repository governance and configuration files added
Added standard repository configuration and governance files, including \.dockerignore\ to exclude build artifacts and secrets, \.editorconfig\ to enforce consistent code formatting (LF line endings, 2-space tabs), \.git-blame-ignore-revs\ to ignore bulk formatting commits, \AGENTS.md\ to provide instructions for AI coding agents, \CITATION.cff\ for academic citation metadata, \CODE\_OF\_CONDUCT.md\ establishing community standards, and \LICENSE\ under the Apache 2.0 license.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 46 → 46 (-0.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 61 → 60 (-1.5)
- Architecture 79 → 79 (-0.7)
- Maturity 66 → 69 (+3.0)
- Readiness 36 → 37 (+0.9)
- Security 60 → 57 (-2.6)
- Accessibility 45 → 45 (-0.5)
- Performance 69 → 69 (+0.0)
Resolved (62)
- Change coupling: templates.py ↔ Index.svelte (gradio/templates.py)
- Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
- Duplicated block (17–19 lines × 2) (gradio/mcp.py)
- Duplicated block (21 lines × 2) (gradio/components/image.py)
- Duplicated block (25 lines × 2) (gradio/themes/ember.py)
- Duplicated block (5 lines × 2) (demo/same-person-or-different/run.py)
- Duplicated block (7–8 lines × 2) (demo/same-person-or-different/run.py)
- Duplicated block (8 lines × 2) (gradio/cli/commands/components/build.py)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- High CVE: [GHSA redacted] (pnpm-lock.yaml)
- Hotspot: gradio/cli/commands/skills.py (gradio/cli/commands/skills.py)
- Hotspot: gradio/components/video.py (gradio/components/video.py)
- Hotspot: gradio/node_server.py (gradio/node_server.py)
- Low CVE: [GHSA redacted] (pnpm-lock.yaml)
- Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
- Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
- …and 42 more
New (75)
- Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
- Documentation: no build, run or usage example (js/imageeditor/README.md)
- Documentation: no build, run or usage example (js/imageslider/README.md)
- Documentation: no build, run or usage example (js/theme/README.md)
- Duplicated block (20 lines × 2) (gradio/mcp.py)
- Duplicated block (7–9 lines × 2) (gradio/history.py)
- Edited copies of one member (3 members, 10+ corresponding lines) (gradio/processing_utils.py)
- Edited copies of one member (3 members, 26+ corresponding lines) (gradio/components/clear_button.py)
- Edited copies of one member (3 members, 42+ corresponding lines) (gradio/components/highlighted_text.py)
- Edited copies of one member (3 members, 8+ corresponding lines) (demo/dashboard/run.py)
- Edited copies of one member (5 members, 37+ corresponding lines) (gradio/components/button.py)
- Edited copy of a member (10 corresponding lines) (demo/asr/run.py)
- Edited copy of a member (10 corresponding lines) (gradio/chat_interface.py)
- Edited copy of a member (11 corresponding lines) (demo/clear_components/run.py)
- Edited copy of a member (14 corresponding lines) (gradio/workflow.py)
- Edited copy of a member (17 corresponding lines) (client/python/gradio_client/utils.py)
- Edited copy of a member (17 corresponding lines) (gradio/cli/commands/components/_docs_utils.py)
- Edited copy of a member (17 corresponding lines) (gradio/components/audio.py)
- Edited copy of a member (18 corresponding lines) (gradio/layouts/group.py)
- Edited copy of a member (18 corresponding lines) (scripts/benchmark_latency_mcp.py)
- …and 55 more
Changes since last survey
- 18 commits — 16 feature/other, 2 fixes
By area
- client/js — 5 commits
- (root) — 3 commits
- js/workflowcanvas — 3 commits
- .changeset/cute-mangos-fetch.md — 1 commit
- .changeset/metal-carrots-visit.md — 1 commit
- .changeset/yellow-pandas-raise.md — 1 commit
- gradio/cli — 1 commit
- js/core — 1 commit
- js/imageeditor — 1 commit
- js/model3D — 1 commit
Notable commits
- fix: Fix two Windows bugs: reused cached files deleted early, misleading reserved-port error (#14064)
- fix: Revert "retry past provider context limits"
- change: Add GitHub-installed CLI extensions (#14042)
- change: Allow Pillow 13 on 6.x and keep 32-bit integer PNG output working (#14034)
- change: Keep the local gradio_client installed when using uv in the repo (#14060)
- change: Require brotli>=1.2.1 ([CVE redacted]) (#14015)
- change: Require login for the MCP server when the app uses auth, and make queued MCP calls work with auth (#14053)
- change: Run a deferred always_last event with its own event data (#13991)
- change: Show an error when camera permission is denied for the webcam (#14027)
- change: Use the visitor's own HF token for run history buckets (#14050)
- change: add console forwarding for embedded apps (#14059)
- change: chore: update versions (#13951)
- change: chore: update versions (#14030)
- change: retry past provider context limits
- change: workflow: add 3d model node support (#14057)
- change: workflow: add embedded inference token (#14037)
- change: workflow: add masked setting on textboxes (#13972)
- change: workflows: handle depth estimation (#14017)
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
gradio-app/gradio was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit ec06278ed72e5eb73494a9d171ca851d553dc82a — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.