unslothai/unsloth

This system is the Unsloth Studio, a comprehensive desktop and web application for managing, fine-tuning, and running large language models and diffusion models. It provides a unified backend and frontend interface for model discovery, dataset preparation via data recipes, and multimodal inference including chat, image, video, and audio generation. The platform supports local hardware acceleration across CUDA, ROCm, and Metal, while offering robust features for model export, retrieval-augmented generation, and secure, multi-user authentication.

The Studio backend now includes a new \configs\ directory containing YAML files (\full\_finetune.yaml\, \lora\_text.yaml\, \vision\_lora.yaml\) that define default settings for full and LoRA finetuning workflows, as well as an \inference\_defaults.json\ file that establishes per-model-family defaults for inference parameters such as temperature, top\_p, and presence\_penalty.

studio/backend/assets/configs · high confidence

Introduces a new 'ExecutionProgressIsland' component in the Recipe Studio runtime area, providing users with a collapsible UI panel that displays real-time status, progress bars, and detailed metrics for recipe executions, including specific handling for GitHub source crawling states and rate limits.

studio/frontend/src/features/recipe-studio/components/runtime · high confidence

Users can now save, load, and delete custom generation presets for both image and video creation. The new PresetControl UI component allows selecting from built-in or user-defined recipes, while the underlying API and hooks handle syncing these settings to the backend. This feature lets users quickly restore preferred configurations without manually re-entering parameters like steps, guidance, or resolution.

studio/frontend/src/features/images · high confidence

A new guided tour has been added to the Export feature to help users understand the workflow. The tour provides step-by-step instructions for selecting a training run, choosing a specific checkpoint, picking an export format (Merged, LoRA Only, or GGUF), and finalizing the export to a local device or Hugging Face repository.

studio/frontend/src/features/export/tour · high confidence

Users can now configure markdown note blocks via a new dialog that allows setting a name, choosing a background color, adjusting opacity, and editing the markdown content. The dialog includes a color picker and an opacity slider for visual customization, along with a text area for the note's markdown body, which is noted as UI-only and not sent to the backend.

studio/frontend/src/features/recipe-studio/dialogs/markdown-note · high confidence

Studio now supports a Find in Page feature triggered by Cmd/Ctrl+F. The implementation uses a lazy-loading pattern where the search bar UI and search engine are loaded on demand, ensuring the initial application load is not blocked. The feature includes a search input with query settling to debounce rapid typing, navigation between matches, and proper focus management to return focus to the previous element upon closing.

studio/frontend/src/features/find-in-page/components · high confidence

A new shared module for toast notifications has been added to the frontend, providing \toastSuccess\ and \toastError\ helper functions that wrap the underlying toast library. This allows components to display success and error messages with consistent formatting and optional descriptions.

studio/frontend/src/shared · high confidence

The Unsloth Studio backend now includes two new Jinja chat templates, \gemma-4.jinja\ and \gemma-4-edge.jinja\, to support Google's Gemma 4 models. These templates handle specific formatting requirements for the E2B/E4B edge variants and larger models, including tool definitions, function calling, and thinking capabilities. They are applied automatically to \unsloth/gemma-4-\*-GGUF\ models to ensure correct prompt structure without requiring external template downloads.

_studio/backend/assets/chat\templates · high confidence

A new Python script, \unsloth\_freeze\_report.py\, has been added to the studio scripts directory to help diagnose interface freezes on the Linux desktop. The tool automatically launches the Unsloth Desktop application multiple times with different environment variable configurations (such as disabling WebKit compositing or switching to X11) to identify which workaround prevents the freeze. It distinguishes between a true interface freeze, a complete application crash, and a signed-out state by monitoring specific backend API endpoints, then generates a local report file containing the results and system details for the user to review.

studio/scripts · high confidence

The studio frontend now includes reusable layout components for the dashboard view. A new \DashboardLayout\ component provides a full-height background with centered content, while a \DashboardGrid\ component offers a responsive grid system supporting 3 or 4 columns. These components are exported from the layout index, and a global stores index file has been added to the stores directory to facilitate future state management exports.

studio/frontend/src/components/layout, studio/frontend/src/stores · high confidence

A new utility function, normalizeNonEmptyName, has been added to the studio frontend to handle string normalization. This function trims whitespace from input strings and returns a fallback value (defaulting to "Unnamed") if the result is empty, providing a consistent way to handle name inputs across the application.

studio/frontend/src/utils · high confidence

The Studio backend now uses a dedicated \studio/backend/utils/paths\ module to manage all file-system locations and path logic. This introduces a unified storage-root system that supports per-account isolation, configurable model download locations (including Hugging Face, LM Studio, and Hermes), and custom install paths via \STUDIO\_HOME\/\UNSLOTH\_STUDIO\_HOME\. It adds robust cross-platform path normalization (handling WSL, Windows drive letters, and POSIX), security hardening by blocking access to sensitive directories (e.g., \.ssh\, \.aws\), and improved scan-folder health reporting to inform users when a model directory is unreadable or missing. It also includes helpers for external media detection on Linux/macOS/Windows and lazy path resolution to prevent stale account identity issues.

studio/backend/utils/paths · high confidence

The chat model picker now includes models sourced from Hermes alongside existing local sources like LM Studio, Ollama, and custom directories. This change ensures that models previously downloaded or managed by the Hermes backend are visible and selectable within the chat interface, allowing users to load them directly without manual configuration.

studio/frontend/src/features/model-picker/inventory · high confidence

Chat presets in the Studio now include model load configuration options, allowing users to save and restore specific runtime settings alongside their prompt parameters. This change introduces a new \PresetLoadConfig\ type that captures knobs such as context length, KV cache data types, speculative decoding modes, parallel slots, batch sizes, GPU memory modes, and vision toggles. When a preset is applied, these load settings are normalized and applied to the runtime, ensuring that complex model configurations are preserved across sessions without requiring manual re-entry.

studio/frontend/src/features/chat/presets · high confidence

The Studio backend now supports registering custom directories for model scanning, storing these paths in a dedicated SQLite table. This feature includes robust validation to prevent users from adding system directories (such as /etc, /proc, or C:\\Windows), sensitive credential folders, or non-readable paths. It also enforces per-account isolation, ensuring that registered scan folders remain within the user's workspace boundaries, and handles cross-platform path normalization for Windows, macOS, and Linux.

studio/backend/hub/storage · high confidence

The frontend now exposes a structured type system for training configurations, introducing \ModelType\ (vision, audio, embeddings, text) and \TrainingMethod\ (qlora, lora, full, cpt) with validation helpers. It also adds \DatasetSource\ to support S3-based dataset loading via a new \S3Config\ interface, alongside definitions for dataset formats and gradient checkpointing strategies.

studio/frontend/src/types · high confidence

The Unsloth desktop application now handles 'unsloth://' deep links to open specific models from Hugging Face Hub. When a user clicks such a link, the app restores the main window if it was hidden (e.g., at login) and navigates to the Hub's model discovery view, pre-filling the model and optional GGUF file details. The implementation includes URL parsing with strict validation for model identifiers and file paths, along with intent deduplication to prevent duplicate actions from rapid successive links.

studio/frontend/src/features/deep-links · high confidence

The update popup now shows users exactly what changed in new versions. For llama.cpp updates, a dedicated panel lists itemized changes sourced from the repository's changelog, including links to relevant documentation or issues. For general Studio updates, the popup fetches and renders full release notes from GitHub, displaying a collapsed summary of key points that expands into a scrollable view of the complete changelog. This allows users to review specific improvements and fixes before applying an update.

studio/frontend/src/components/update · high confidence

The Studio frontend now includes comprehensive translation files for Arabic (ar), German (de), Spanish (es), French (fr), Hindi (hi), and Italian (it). These locale files cover the full message tree—including composer settings, prompt queue interactions, model picker states, and navigation labels—enabling users to interact with the Unsloth Studio interface in their preferred language.

studio/frontend/src/i18n/locales · high confidence

A new GitHub Crawler recipe has been added to the Easy view, allowing users to crawl GitHub issues and PRs to generate training pairs. This view includes a form for configuring the GitHub repository seed and run settings, specifically supporting a local model selector for choosing which local model to load for generation.

studio/frontend/src/features/recipe-studio/easy · high confidence

The chat interface now supports HTML artifacts, allowing the model to generate interactive previews directly within the conversation. These artifacts appear as cards in the chat stream and can be opened in a side panel or overlay, where users can toggle between a live preview and the underlying source code. The system handles both fenced HTML blocks and tool-call-generated content, automatically rendering them in a sandboxed iframe. To ensure security, network access for the canvas is disabled by default; if a preview is blocked by the Content Security Policy, a banner appears allowing the user to grant network access for that specific canvas. The implementation includes a dedicated state store to manage artifact lifecycle, auto-opening behavior, and thread-scoped cleanup.

studio/frontend/src/features/chat/artifacts · high confidence

The Hub feature module has been reorganized into a dedicated directory structure, introducing a new HfTokenIndicator component that displays a masked preview of the saved Hugging Face token and provides a tooltip to open Settings. A new PageHeading component standardizes title and subtitle rendering, while a custom TrainIcon is created by slicing a base icon to remove interior details. The hub-page.tsx entry point has been significantly expanded to support a full-page redesign with trending feed, search, and persisted state, including responsive layout adjustments for various screen sizes. CSS variables and styles have been added to support the new Hub UI, including format/status color tokens and a 'field-soft' class for search and filter controls. The module's index.ts now exports a comprehensive set of hooks, stores, and utilities for inventory, downloads, and model selection.

studio/frontend/src/features/hub · high confidence

Recipe Studio now supports inline editing for several node types, allowing users to modify settings directly on the canvas without opening separate dialogs. New components include inline editors for model configurations (including local model selectors and provider sync), LLM settings (model alias, tool profiles, and code language), seed sources (Hugging Face, GitHub repositories, and local files), expressions (with Jinja reference validation), and samplers (uniform, gaussian, bernoulli, and UUID). A policy module determines which node types use inline versus dialog modes, and a new badge component handles overflow display for category values.

studio/frontend/src/features/recipe-studio/components/inline · high confidence

Recipe Studio now includes two new shared UI components to improve the editing experience. The AvailableReferencesInline component displays a list of available variables as badges, intelligently collapsing them into a limited number of rows with an expandable toggle to manage screen space. Additionally, the HfDatasetCombobox component provides an inline search interface for Hugging Face datasets, allowing users to find and select datasets directly within the studio interface with debounced search and loading states.

studio/frontend/src/features/recipe-studio/components/shared · high confidence

Users can now observe real-time OpenAI-compatible API traffic via a new floating overlay panel and a dedicated full-page dashboard. The overlay automatically appears when API calls are detected, showing a summary of active requests, status, and throughput, and can be dismissed or toggled via keyboard shortcut. The full-page monitor provides detailed request logs, filtering by status, search capabilities, and controls to clear the log or unload the currently resident model. This feature adds observability into API usage without disrupting the main chat interface.

studio/frontend/src/features/api-monitor · high confidence

The Data Recipe backend now includes core modules for managing recipe execution artifacts. Users can export recipe datasets to JSONL or Parquet formats, with image assets included in the archive when present. The system integrates the OXC validator to support syntax and linting checks on JavaScript/TypeScript code within recipes, running via a local Node.js runtime. Additionally, recipe datasets can be published to Hugging Face, with seed tokens automatically stripped from the configuration for security. The backend also handles JSON serialization of complex types (like Pandas/NumPy objects) and normalizes image contexts for preview and export.

_studio/backend/core/data\recipe · high confidence

The Data Recipe module now includes a backend job management system that executes recipe runs in isolated subprocesses and streams structured progress events to the UI. This change adds a JobManager to coordinate single-job execution, a log parser to translate raw worker output into detailed stage and progress updates (including GitHub source fetching, column generation, and batch processing), and a worker entry point that handles preview and full execution modes while sanitizing sensitive tokens from logs.

_studio/backend/core/data\recipe/jobs · high confidence

The Data Recipes feature is now available in the Studio frontend, exposing the DataRecipesPage, EditRecipePage, and a preload function for recipe data. This change introduces the core TypeScript types (RecipeRecord, SaveRecipeInput) that define the structure for saving and managing recipes, including support for linking to learning recipes, laying the groundwork for the recipe management workflow.

studio/frontend/src/features/data-recipes · high confidence

Recipe Studio now includes dedicated dialogs for configuring LLM steps, allowing users to set up model aliases, providers, and tool profiles. Key additions include support for LLM trace modes (none, last\_message, all\_messages) and reasoning content extraction, as well as an image context selector for multimodal inputs. For LLM Judge steps, a new Scores tab enables users to define custom scorer rubrics with multiple options. The dialogs also feature Jinja reference validation to highlight invalid field references in prompts and system prompts, and persist advanced collapsible states across sessions.

studio/frontend/src/features/recipe-studio/dialogs/llm · high confidence

The Studio frontend now includes a new MarkdownPreview component that renders markdown content using the Streamdown library, featuring optimized plugin loading for code, math, and Mermaid diagrams. This update adds robust error handling for Mermaid chart rendering, displaying a user-friendly error message with a retry button and specific hints for common syntax issues like incorrect comment styles.

studio/frontend/src/components/markdown · high confidence

The backend now uses the OXC engine to validate JavaScript and TypeScript code within data recipes. This change adds a new validation module that supports syntax checking, linting, and combined modes, with configurable code shapes (auto, module, snippet) and language mapping. It includes robust error normalization for parser and lint diagnostics, handles snippet offset remapping, and implements safeguards against subprocess hangs by managing timeouts and budget margins for the OXC validator.

_studio/backend/core/data\recipe/oxc-validator · high confidence

The Data Designer now supports a new plugin that allows users to ingest unstructured text files (such as .txt and .md) as seed data. This feature automatically chunks the text content based on configurable size and overlap parameters, caches the resulting parquet datasets, and provides preview rows for validation. The implementation handles multi-file uploads, preserves original filenames via metadata, and ensures pandas is only loaded when necessary to avoid startup overhead.

studio/backend/plugins/data-designer-unstructured-seed · high confidence

The Studio now includes a dedicated Audio page that consolidates text-to-speech (TTS) generation and speech-to-text (STT) transcription into a single interface. Users can switch between Generate and Transcribe modes, each with its own model picker and settings. The page features a gallery for generated audio clips and transcripts, supporting pinning, archiving, and deletion. It also includes a guided tour to help users navigate the new features, and supports recording audio directly from the microphone for transcription.

studio/frontend/src/features/audio · high confidence

Added a new data layer (recipes-db.ts) that stores Data Recipes locally in the browser using Dexie (IndexedDB), enabling immediate tab navigation and offline availability. The implementation includes caching, live-reactive hooks for UI updates, and support for creating drafts or templates from learning recipes, with per-account isolation via the account database name.

studio/frontend/src/features/data-recipes/data · high confidence

The Studio backend now includes a new \studio/backend/core/rag\ package that centralizes Retrieval-Augmented Generation logic. This update adds vision-model helpers for figure captioning and scanned-page OCR, a configurable embedding system that supports both sentence-transformers and a dedicated llama.cpp subprocess (GGUF) to keep the main process GPU-free by default, and a durable folder-sync mechanism for linking local directories to the knowledge base. It also introduces page-aware chunking with token overlap and a conversation archive that indexes evicted chat turns for recall, replacing the previous ad-hoc ingestion and retrieval code.

studio/backend/core/rag · high confidence

The Recipe Studio now uses a centralized, modular system for managing canvas blocks. A new \definitions.ts\ file establishes the core block types (sampler, seed, LLM, validator, expression, note) and their metadata, including specific seed sources like Hugging Face, local files, unstructured documents, and GitHub repositories. The \registry.ts\ file exports these definitions and helper functions, while \render-dialog.tsx\ provides a unified switch-case mechanism to render the appropriate configuration dialog for each block type. This change replaces previous ad-hoc block handling with a structured, maintainable approach that supports the new validator blocks and markdown notes.

studio/frontend/src/features/recipe-studio/blocks · high confidence

The model picker now supports saving and applying specific configuration settings (such as context length and other parameters) on a per-model basis. This change introduces the necessary hooks, stores, and API utilities to persist these preferences, ensuring that remembered settings are automatically applied when loading models via the API or runtime, rather than relying on global defaults.

studio/frontend/src/features/model-picker · high confidence

The Studio now remembers and applies specific load settings (such as context length, GPU offloading, speculative decoding, and batch size) individually for each model, rather than using a single global configuration. This change introduces a new internal module in the model picker that handles the persistence, drafting, and application of these per-model settings to the runtime, ensuring that switching between models restores their unique configurations automatically.

studio/frontend/src/features/model-picker/model-config · high confidence

The Studio now scans models for custom code (trust\_remote\_code) and unsafe files before loading them. A new security feature scans the model's auto\_map for remote code execution risks and flags unsafe serialized files (e.g., malicious pickles). If remote code is detected, a consent dialog appears, showing the model provider, severity of findings, and the specific code snippets flagged. Users can approve or decline the request. If approved, the approval is cached per user and pinned to the code's fingerprint, so future loads of the same code skip the dialog. If declined, any repositories downloaded by the scan are purged. Critical findings or unsafe files result in a hard block that cannot be overridden.

studio/frontend/src/features/security · high confidence

The seed configuration dialog in Recipe Studio now supports configuring data sources via GitHub repositories and uploading unstructured files. Users can input GitHub repository slugs to ingest issues and pull requests, with validation for owner/name format and limits on the number of items. Additionally, a new drop-zone component allows uploading unstructured files (such as .txt, .pdf, .docx, .md) with server-side processing, enforcing per-file (500MB) and total (1GB) upload limits. The dialog also includes options for sampling strategies (ordered/shuffle) and selection types (none/index range/partition block), along with UI components for field labels and collapsible sections to manage these configurations.

studio/frontend/src/features/recipe-studio/dialogs/seed · high confidence

The Studio frontend now uses a new \AuthForm\ component that handles both login and initial password setup. It displays a countdown timer indicating when the browser will shut down if the default admin password is not changed, and automatically redirects users to the change-password screen if required by the server state. The form also supports seeding the initial password from bootstrap credentials injected into the HTML, and manages session refresh and token storage during the authentication process.

studio/frontend/src/features/auth/components · high confidence

Adds a new video generation page to the Studio frontend, enabling users to generate videos using the MiniMax-H3 model. This includes a dedicated API layer for model loading and generation status, a guided tour for the new workflow, and specific UI components for managing references: users can now upload and crop reference images, select reference videos and audio clips with size and duration validation, and trim reference videos to the required 2–15 second window. The feature also implements concurrency limits for thumbnail generation to prevent backend overload.

studio/frontend/src/features/video · high confidence

Adds the primary API client module for the Recipe Studio feature, establishing the frontend's communication layer with the backend. This client now handles authentication via \authFetch\, supports streaming event feeds for real-time progress updates, and exposes types and methods for managing recipe jobs, dataset seeds, and execution analysis. It also includes error handling utilities for FastAPI responses and configuration for the data designer API base URL.

studio/frontend/src/features/recipe-studio/api · high confidence

The Studio backend now includes a new \studio/backend/utils/prebuilt\ package that centralizes the logic for managing prebuilt inference servers. This adds shared mechanics for checking prebuilt freshness and handling in-app updates, including robust GitHub API rate-limit detection and retry advice. It also introduces strict child-process environment hygiene that scrubs secrets and isolates credential-store paths when launching downloaded binaries, and provides canonical backend resolution logic to correctly map install kinds and asset names to CUDA, ROCm, Vulkan, CPU, or Metal backends across different operating systems.

studio/backend/utils/prebuilt · high confidence

The \studio/backend/storage\ package now contains dedicated SQLite persistence modules for several Studio capabilities, including API usage receipts, chat generation runs, credential secrets, library items, MCP servers, profile statistics, LLM providers, RAG knowledge bases, and Deep Research runs. This change establishes the backend data layer that enables features such as profile usage tracking, encrypted credential storage, and durable chat/research state.

studio/backend/storage · high confidence

The chat interface now supports voice dictation using local speech-to-text models and custom external STT endpoints, in addition to the existing browser-based Web Speech API. This change adds a new dictation adapter layer in the chat frontend that routes audio input to the selected engine, handling microphone access, audio level metering, and session management. To ensure compatibility across browsers and platforms (such as Linux WebKitGTK where standard media recording may fail), a new PCM recorder captures raw audio and encodes it into WAV format for reliable backend processing. The system also includes specific error handling for missing local models and custom configuration states, providing users with clear guidance and fallback options when dictation features are unavailable.

studio/frontend/src/features/chat/adapters · high confidence

The Studio frontend now enforces type safety for chat interactions by adding dedicated type definitions in \studio/frontend/src/features/chat/types\. The \api.ts\ file defines the request and response schemas for model loading, validation, and GGUF variant management, including new fields for speculative decoding, GPU memory strategies, and audio device selection. The \research.ts\ file introduces a comprehensive type system for the Deep Research feature, covering run statuses, planning steps, evidence sources, and event data streams. Additionally, \runtime.ts\ establishes the structure for inference parameters (such as temperature, minP, and sampling seeds) and model summaries, ensuring consistent data handling across the chat interface.

studio/frontend/src/features/chat/types · high confidence

The Recipe Studio now stores recipe execution records locally in the browser using IndexedDB, enabling users to view their execution history even when offline or after refreshing the page. This change introduces a new database schema with two versions: the initial version tracks basic execution details (ID, recipe ID, kind, status, and creation time), while the second version extends this to include finish time and job ID, allowing for more detailed progress analysis. The implementation uses account-scoped storage to ensure data isolation across different user accounts within the same browser profile.

studio/frontend/src/features/recipe-studio/data · high confidence

Studio now allows users to load local GGUF models directly via drag-and-drop. The new NativeModelChip component displays the selected model with options to load it into the chat, reveal its file path, or dismiss it, while the NativeModelDropOverlay provides visual feedback and status messages during the drop interaction.

studio/frontend/src/features/native-intents/components · high confidence

The Studio desktop app now handles native operating system file drops (drag-and-drop from the file manager) directly into the chat and model interfaces. This new \native-intents\ feature bridges the gap between the Tauri desktop environment and the webview, allowing users to drop documents, images, audio, video, and GGUF model files without them being rejected. The system classifies dropped files, registers them securely via native path leases, and queues them for attachment or model loading, ensuring that drops land on the correct UI element even when the webview's internal drop events are suppressed by the OS.

studio/frontend/src/features/native-intents · high confidence

Added a new \unsloth/unsloth-rocm\ Docker image for AMD GPUs (RDNA2 through RDNA4 and CDNA), including a \studio\ variant with the web UI and JupyterLab. The change introduces \Dockerfile.rocm\ and \Dockerfile.studio-rocm\ to build the ROCm stack, along with \DOCKERHUB-ROCM.md\ documentation and a \.dockerignore\ file to streamline the build context. This allows users to fine-tune and run LLMs on AMD hardware using the same workflow as the existing CUDA images.

docker · high confidence

A new 'Settings applied on API load' panel has been added to the API Monitor, allowing users to view and manage saved per-model configuration overrides. This component displays a summary of specific settings that will be applied when a model is loaded via the API (such as context length, KV cache dtype, batch sizes, and reasoning budgets) and provides the ability to 'forget' (delete) these saved entries directly from the monitor, ensuring they are cleared from both local and remote storage.

studio/frontend/src/features/api-monitor/components · high confidence

The Studio now provides a dedicated API endpoint (\/api/profile/stats\) that returns comprehensive usage data for the user's profile. This includes daily activity metrics (tokens, messages, chats), breakdowns by model, performance speed indicators (tokens per second, response latency), and training run history. The frontend client now fetches this data using the user's local timezone to ensure accurate historical date bucketing, enabling the UI to display detailed insights into usage patterns and API token consumption.

studio/frontend/src/features/profile/api · high confidence

The studio backend now exposes two new routes for managing model chat templates. Users can POST to /validate-chat-template to check if a custom template is valid, and GET /chat-template/{model\_name} to retrieve the default chat template for a specific model (optionally specifying a GGUF variant). These endpoints enforce account-based model access controls and handle offline scenarios gracefully, ensuring that template retrieval does not fail unexpectedly when the hub is unreachable.

studio/backend/picker/routes · high confidence

The model picker now communicates with the backend via a dedicated API layer, introducing server-side persistence for per-model settings (model-overrides.ts) and a one-time migration to backfill local browser settings into the server (migrate-model-overrides.ts). Users benefit from accurate, real-time memory estimates for model loads (memory-estimate.ts), automatic validation of custom chat templates (templates.ts), and dynamic detection of supported llama-server flags (llama-flags.ts). Additionally, the system can now fetch model metadata such as maximum context length directly from the model configuration (model-metadata.ts).

studio/frontend/src/features/model-picker/api · high confidence

The Studio frontend now includes a comprehensive set of new API client modules in the settings area, enabling users to manage a wide range of configuration options directly from the UI. These modules provide the frontend logic to fetch, update, and monitor settings for account management, API key access, cache inventory and purging, download transport selection, embedding model configuration, helper LLM precaching, Hugging Face hub endpoints, LAN access, and llama.cpp backend switching. This change introduces the necessary data-fetching and state-management layers for these settings, allowing users to customize their environment, manage resources, and control model behavior without needing to edit configuration files manually.

studio/frontend/src/features/settings/api · high confidence

The Data Recipes section now includes a dedicated landing page and an editing interface. The landing page features a guided tour to help users navigate the new workflow and presents a selection of learning recipe templates (such as Instruction from Answer, PDF Document QA, and GitHub Crawler) that users can use to quickly generate training data. The editing page allows users to load, modify, and save existing recipes, integrating with the Recipe Studio for detailed configuration.

studio/frontend/src/features/data-recipes/pages · high confidence

Unsloth Studio now includes a new data-designer plugin that lets users generate training datasets directly from live GitHub repositories. By specifying one or more \owner/name\ repos, a GitHub token, and desired item types (issues, pull requests, or commits), the plugin scrapes the data via the GitHub GraphQL API and outputs a unified JSONL seed file. The reader supports configurable limits, optional inclusion of issue/PR comments, and handles authentication via explicit tokens or environment variables (\GH\_TOKEN\/\GITHUB\_TOKEN\), with built-in rate-limit awareness and caching to avoid redundant scraping.

studio/backend/plugins/data-designer-github-repo-seed · high confidence

The backend now exposes a structured Hub API layer with Pydantic schemas for managing model inventory, download jobs, and dataset operations. Users can now interact with a standardized interface for discovering local and remote models (including GGUF variants and companion assets), initiating and monitoring downloads with transport-specific capabilities (Xet/HTTP), and validating or uploading datasets with AI-assisted mapping. This introduces new endpoints for listing cached models, tracking download progress, and handling dataset formats, enabling more robust model management and data preparation workflows within the Studio.

studio/backend/hub/schemas · high confidence

The Studio backend now exposes a new Hub and Download Manager feature module, introducing dedicated API routes for model and dataset inventory management, Hugging Face token validation, and secure endpoint proxying. Users can now manage local model and dataset caches, initiate and monitor downloads, and browse Hugging Face repositories through a same-origin proxy that respects custom endpoints and enforces strict token boundaries to prevent credential leakage to API key callers.

studio/backend/hub/routes · high confidence

The Hub feature now includes a suite of new library modules that power model discovery and display. These include channel presets for trending, latest, and fine-tune-ready models, format filters to distinguish GGUF from safetensors, and logic to hide infrastructure models like RAG embedders and STT engines from the chat picker. The update also introduces utilities for formatting file sizes and ETAs, sorting GGUF variants by fit and download status, and caching Hugging Face model metadata and READMEs with concurrency limits and timeout handling.

studio/frontend/src/features/hub/lib · high confidence

This change introduces the core frontend infrastructure for the new Library page, enabling users to browse, organize, and interact with uploaded files, generated media (images, video, audio), and fine-tuned models. It adds the \LibraryActionsContext\ for managing operations like downloading, renaming, moving items into folders, and deleting, alongside a \LibraryChatHandoffStore\ to seamlessly attach library files to a new chat composer. The implementation includes API clients for fetching library snapshots and managing storage locations, as well as UI components for card and list views, a header with tabbed navigation, and a preview pane that supports viewing text, code, and media directly within the studio.

studio/frontend/src/features/library · high confidence

A new corner indicator has been added to the Studio interface to display all currently resident models across the chat, image, video, and dictation runtimes. Users can now view which models are loaded in memory and individually eject them to free up resources, with the indicator appearing by default but controllable via a new setting in General preferences. The feature includes a draggable panel, persistence of position and state across reloads, and handles complex backend behaviors such as cached models and mid-ejection runtime switches.

studio/frontend/src/features/loaded-models · high confidence

The Studio frontend now includes a dedicated API client for Retrieval-Augmented Generation (RAG) features, introducing structured handling for knowledge bases, document uploads, and project sources. This change adds a Zustand-based availability store that tracks whether the RAG engine (sqlite-vec) is supported on the current host, allowing the UI to gracefully handle unsupported environments rather than failing silently. The client also implements robust error parsing for FastAPI responses and manages the lifecycle of document indexing jobs, ensuring users receive appropriate feedback when saving markdown as project sources or uploading files to knowledge bases.

studio/frontend/src/features/rag/api · high confidence

The Studio frontend now includes a new set of components in the RAG feature area to support knowledge bases, document previews, and project-level sources. Users can now manage knowledge bases (create, edit, delete, and add documents) via a dedicated dialog, and select a knowledge base as the retrieval source in the chat composer. Document previews are now available for PDFs, with lazy-loaded rendering, zoom, and page navigation. Project sources can be managed via a dedicated panel, supporting drag-and-drop uploads and linked folders. Retrieval settings (search mode, top K, auto-retrieve) are now configurable in a dedicated section. These components provide the UI foundation for the RAG feature, with the actual retrieval logic handled elsewhere.

studio/frontend/src/features/rag/components · high confidence

Recipe Studio now includes dedicated dialog components for managing recipe settings and execution. Users can configure individual recipe steps (including a new 'drop' toggle to exclude intermediate steps from the final dataset), import and export recipes via JSON, and adjust run settings such as row counts and advanced execution parameters in the preview dialog. Additionally, a new processors dialog allows users to enable and configure a schema transform processor using a Jinja-based template to reshape final output rows.

studio/frontend/src/features/recipe-studio/dialogs · high confidence

Added a new set of utility modules in \studio/frontend/src/features/recipe-studio/utils/import\ to handle the parsing and reconstruction of Recipe Studio canvas configurations. This includes \importer.ts\ for orchestrating the import of recipe payloads (including model configs, processors, and seed settings), \edges.ts\ for building graph connections based on semantic and data relationships, \ui.ts\ for parsing node layouts and auxiliary nodes, and supporting parsers for columns, helpers, and type definitions. These changes enable the frontend to correctly interpret and render imported recipe structures, including handling layout directions, node positions, and edge types.

studio/frontend/src/features/recipe-studio/utils/import · high confidence

The Recipe Studio frontend now uses dedicated Zustand stores to manage canvas state and execution lifecycle. The new \recipe-studio.ts\ store centralizes graph operations (nodes, edges, layout direction, and block addition) and exposes actions for adding specific block types like validators and markdown notes. A new \recipe-executions.ts\ store manages run settings (including batch processing and LLM parallel requests), tracks loading states for previews and full runs, and maintains a history of execution records. Helper modules (\recipe-studio-helpers.ts\) provide utilities for node updates, edge synchronization, and configuration changes, replacing previous ad-hoc state handling.

studio/frontend/src/features/recipe-studio/stores · high confidence

The Settings feature now includes a new library of TypeScript modules that power several user-facing capabilities: agent model selection logic filters Hub models by pipeline tags to distinguish chat-generative, speech-only, and classifier/reranker models; a debug log viewer with configurable refresh modes (live, 3s, manual), request timeouts, and buffer management; interface scaling support for macOS titlebar insets; a comprehensive keyboard shortcut registry with rebindable chords for navigation, chat actions, and workspace switching; localized labels for llama.cpp backends (CPU, CUDA, ROCm, Vulkan, Metal); and a download tracking system for STT (speech-to-text) dictation models that mirrors progress in the shared download panel and handles cancellations.

studio/frontend/src/features/settings/lib · high confidence

The Studio frontend now includes a comprehensive set of new UI components, including Accordion, AlertDialog, Alert, AnimatedShinyText, AnimatedThemeToggler, AspectRatio, Avatar, Badge, Breadcrumb, Button, Calendar, Card, Chart, Checkbox, Collapsible, Combobox, and Command. These components provide a consistent, modern interface for users interacting with the Studio application, featuring enhanced styling, animations, and accessibility improvements.

studio/frontend/src/components/ui · high confidence

The Studio backend now serves a dedicated preview page (accessible via /p) that displays the model's conversation thread. This page supports both light and dark color schemes based on system preferences and includes specific styling to render the model's internal 'thinking' process in a collapsible, muted section. It also features error handling and loading indicators for a complete user-facing preview experience.

studio/backend/assets · high confidence

The desktop application now includes a dedicated set of frontend components for the Tauri window lifecycle and user interface. This adds a startup screen that displays rotating status messages and installation progress, an update screen with a download progress bar and retry options, and a closing overlay to indicate backend shutdown. It also introduces a custom window titlebar with platform-specific navigation controls (sidebar toggle, back/forward) and an update banner that displays version changes and release notes.

studio/frontend/src/components/tauri · high confidence

The Studio frontend now includes a dedicated authentication module that manages user sessions via localStorage, supporting both single-owner and multi-account login modes. It introduces automatic authentication for the Tauri desktop application, allowing the app to silently log in or refresh tokens without user interaction. The system also handles password-change requirements by redirecting users to a dedicated change-password page and provides a bootstrap shutdown deadline countdown for the browser to inform users when the application is about to close.

studio/frontend/src/features/auth · high confidence

The Studio backend now includes a dedicated dataset services module (\studio/backend/hub/services/datasets\) that introduces several new capabilities. It provides a cache inventory system to track, size, and delete cached Hugging Face datasets, including logic to handle partial downloads and merge metadata from multiple sources. A new download manager handles dataset retrieval with per-account isolation, registry-based locking to prevent conflicts during purges or concurrent downloads, and size/caching optimizations. The module also adds local dataset support, allowing users to upload and manage tabular files (CSV, JSON, Parquet) via a new upload endpoint and listing service. Finally, it introduces dataset formatting and preview utilities that sanitize and serialize image, audio, and binary data for safe client-side display, along with robust option parsing for dataset configs and splits.

studio/backend/hub/services/datasets · high confidence

The Studio backend now includes a new \studio/backend/hub/utils\ package that introduces robust support for managing model companion assets (such as text encoders and VAEs separate from GGUF denoisers), structured caching for processed datasets, and reliable download state tracking via manifests and cancel markers. These utilities ensure that companion files are correctly identified and preserved during cleanup, that dataset processing caches are safely managed with atomic writes, and that download progress and cancellation states are accurately tracked across different transport methods (HTTP and Xet).

studio/backend/hub/utils · high confidence

This change introduces several new components to the chat interface: audio upload capabilities (chat-audio-upload-mount, chat-audio-upload), a model switch notice (chat-model-notice, chat-model-notice-switch) that allows users to switch back to the model a chat was started on, a chat row menu (chat-row-menu) for forking and exporting chats, a chat search dialog (chat-search-dialog), a skills dialog (chat-skills-dialog), a context usage bar (context-usage-bar), a deep research composer button (deep-research-composer-button), a delete chat files switch (delete-chat-files-switch), and an edit project dialog (edit-project-dialog).

studio/frontend/src/features/chat/components · high confidence

The studio backend now includes a new \core\ package that centralizes backend functionality. To improve startup performance and prevent heavy ML libraries from loading in subprocesses, the module uses lazy imports via \\_\getattr\\_\. It also introduces platform-specific stability fixes: a guard on Windows to prevent \torch.compile\ crashes when Triton's C toolchain is missing headers, and import stubs for \torchao\ and \xformers\ to handle missing ROCm backends on Windows. Additionally, the module includes helpers for resolving namespace-package shadows, a comprehensive file library system for managing user uploads and attachments, a supervisor for local Deep Research runs, tool-call parsing and healing logic, and a YouTube transcript fetcher.

studio/backend/core · high confidence

The Recipe Studio now features a comprehensive execution detail view that includes a sidebar for selecting runs, an overview tab displaying run summaries and data insights (such as null rates and side-effect columns), a data tab for browsing and paginating dataset samples with column visibility controls, and a columns tab showing detailed per-column statistics. Users can also download execution datasets as JSONL files and publish completed runs directly to Hugging Face repositories via a new dialog.

studio/frontend/src/features/recipe-studio/components/executions · high confidence

The export panel now features dedicated components for configuring export settings: a method picker allows users to choose between different export formats (such as GGUF, LoRA, or merged) with disabled states and tooltips for context; a quantization picker enables multi-select of quantization levels (e.g., Q2–Q5) with size estimates and recommended badges; and an export run panel manages the execution state, displaying progress, logs, and elapsed time. These components replace the previous configuration interface, providing a more structured and informative workflow for setting up model exports.

studio/frontend/src/features/export/components · high confidence

The Studio now features a dedicated export page that allows users to export trained models in three formats: Merged (full 16-bit), LoRA (lightweight adapter), and GGUF (quantized for local runners). The interface includes a method picker, a quantization selector for GGUF (supporting IQ, Q2–Q8, BF16, FP16, and portable FP8/INT8 via torchao), and a source selector for local models, checkpoints, or Hugging Face models. The page also includes a guided tour, export progress tracking, and size estimation.

studio/frontend/src/features/export · high confidence

The studio frontend now includes a dedicated find-in-page library that introduces a new text indexing and DOM highlighting system. This change adds a pure text-indexing module that flattens searchable content while respecting grapheme boundaries and specific character folding rules, alongside a DOM module that utilizes the CSS Custom Highlight API for non-intrusive match visualization. The implementation defines specific data attributes to control search scope and portal visibility, ensuring that the find bar correctly indexes visible text across the shell and portaled surfaces while skipping hidden or non-searchable regions.

studio/frontend/src/features/find-in-page/lib · high confidence

A new interactive guided tour has been added to the API Monitor feature to help users understand the interface. The tour highlights three key areas: the API endpoint and its status, the toolbar controls for pausing the feed and managing VRAM, and the request log for viewing detailed prompt and reply information.

studio/frontend/src/features/api-monitor/tour · high confidence

Studio now includes a new guided tour feature that highlights specific UI elements using a spotlight overlay and provides step-by-step instructions. The tour system supports auto-triggering based on user history, respects reduced motion preferences, and features a confetti celebration effect upon completion. It is integrated across multiple Studio pages including Data Recipes, API Monitor, Projects, Studio, Export, Images, Video, Audio, Chat, and Hub.

studio/frontend/src/features/tour · high confidence

The studio now includes dedicated onboarding tours for three key areas. The Data Recipes tour guides users through building datasets, viewing existing recipes, or exploring learning recipe templates. The Hub tour helps users discover models, search the catalog, check local hardware constraints, and manage downloaded models. The Recipe Studio tour explains the editor views (Easy form vs. Advanced node graph), saving, and running recipes to produce training datasets.

studio/frontend/src/features/data-recipes/tour, studio/frontend/src/features/hub/tour, studio/frontend/src/features/recipe-studio/tour · high confidence

The Studio now includes structured onboarding tours for the chat interface and project management. The chat tour highlights key features such as model selection (including local GGUF/safetensors and cloud providers), tool attachments, run settings, and the new model comparison view, while the project tour explains how to create, import, and export projects. These tours are context-aware, dynamically showing steps for navigation or comparison only when those features are available, and guiding users through specific UI targets like the model selector popover and settings panel.

studio/frontend/src/features/chat/tour · high confidence

The Data Recipes feature now includes seven pre-built learning recipe templates to help users generate training data for various tasks. These templates cover structured support ticket triage with Jinja conditionals, PDF-based question answering, generating instructions from existing answers, Python code generation with quality judging, SQL query generation with validation, OCR document extraction from images, and crawling GitHub issues/PRs into training pairs. Each template provides a complete workflow configuration including model providers, data sampling strategies, and UI node layouts to get started quickly.

studio/frontend/src/features/data-recipes/learning-recipes · high confidence

Recipe Studio now includes dedicated dialogs for managing model providers and model configurations. The new Model Provider Dialog allows users to define connections as either local (using the model loaded in the Chat tab) or external endpoints, supporting configurable provider types, API keys, and advanced request overrides. The Model Config Dialog enables users to create reusable model presets by selecting a provider connection and specifying a model ID; for local providers, it features a new Local Recipe Model Selector that detects and lists local models from various sources (such as HF cache, LM Studio, Ollama, and Hermes) and handles GGUF quantization variants. These changes streamline the setup of AI steps by centralizing provider and model selection logic within the Recipe Studio interface.

studio/frontend/src/features/recipe-studio/dialogs/models · high confidence

The Studio backend now uses a dedicated authentication module that replaces the previous JWT implementation with a structured system supporting access and refresh tokens, SQLite-based user storage, and keyless API access. Users benefit from a more secure login flow with automatic token refresh, a bootstrap password mechanism for first-run setups, and the ability to access the API without credentials when keyless access is enabled.

studio/backend/auth · high confidence

Users can now customize their display name, nickname, and avatar (including shape preference) via a new profile personalization panel in settings. Changes are saved automatically on blur or Enter, persisted to local storage, and reflected across the app in the sidebar, chat messages, and greeting. The component includes validation, error handling for image uploads, and integration with the existing UI store for consistent state management.

studio/frontend/src/features/profile/components · high confidence

The Settings \> Profile tab now includes a comprehensive statistics section that displays user activity and training metrics. This new panel features headline summaries (lifetime tokens, peak usage, streaks), a token activity heatmap with daily/weekly/cumulative views, detailed activity insights (chats, messages, tokens, speed, tool calls), a top-models leaderboard, and a training highlights card showing runs, steps, and loss. The data is sourced from local history via the profile stats API, formatted according to the user's locale, and loaded lazily to avoid impacting the main bundle.

studio/frontend/src/features/profile/components/stats · high confidence

Recipe Studio now includes dedicated UI dialogs for configuring specific data samplers, allowing users to fine-tune generation parameters directly within the interface. The new components cover Bernoulli (probability), Category (values, weights, and conditional rules), Datetime (start/end ranges and granularity), Gaussian (mean, standard deviation, and type conversion), Person (locale, sex, age range, city), Subcategory (parent category mapping), Timedelta (offsets and reference columns), Uniform (min/max and conversion), and UUID (formatting). Each dialog provides a consistent interface for setting sampler-specific properties, enabling more precise control over synthetic data generation.

studio/frontend/src/features/recipe-studio/dialogs/samplers · high confidence

Added several new scripts to the \scripts/\ directory to support the Unsloth Studio product. \build\_prequant\_checkpoint.py\ and \build\_te\_prequant\_checkpoint.py\ allow users to pre-quantize transformer and text-encoder components (e.g., to fp8) for faster, lower-memory loading in the diffusion backend. \diffusion\_bench.py\ and \diffusion\_quality.py\ provide standalone GPU benchmarking and accuracy validation (PSNR/SSIM) for GGUF diffusion models. \check\_frontend\_dep\_removal.py\ and \check\_new\_install\_scripts.py\ are CI helpers that prevent breaking npm dependency removals and flag new packages with install scripts, respectively. \build\_whisper\_cpp.sh\ automates the build of the whisper-server binary for the local speech-to-text engine, and \compare\_engines.py\ facilitates head-to-head performance comparisons between PyTorch and native stable-diffusion.cpp backends.

scripts · high confidence

The settings interface now includes dedicated components for managing agent startup commands (with platform-specific shell quoting and URL handling), viewing and revoking API keys with relative timestamps, and customizing the application's appearance through a popover color picker and font selection controls. Additionally, the settings area provides dialogs for managing archived chats and media (images, audio, video) with bulk restore and delete actions, a row-based view for cache storage management with purge capabilities, a dialog for changing account passwords, and configuration options for the chat composer such as send shortcuts and follow-up behavior.

studio/frontend/src/features/settings/components · high confidence

The settings area now includes several new React hooks to enhance user control and feedback. Users will see warnings when disk space is low, with a direct link to clear caches. The model settings allow switching between llama.cpp backends, with real-time status updates and toast notifications for success or failure. Additionally, a new keyboard shortcut system is introduced, allowing users to view and rebind chords, with support for context-aware activation (e.g., ignoring shortcuts in text fields) and desktop menu triggers.

studio/frontend/src/features/settings/hooks · high confidence

Added a set of reusable React components in the \studio/frontend/src/features/recipe-studio/dialogs/shared\ directory to standardize the Recipe Studio dialog interface. This includes \AvailableVariables\ for displaying variable references with expandable user fields, \CollapsibleSectionTriggerButton\ for section toggles, \DialogShell\ for consistent header styling, \FieldLabel\ with tooltip support, \NameField\ for input handling, and \ValidationBanner\ for displaying configuration errors. These components replace inline implementations to improve consistency and maintainability across dialog interactions.

studio/frontend/src/features/recipe-studio/dialogs/shared · high confidence

The Hub feature area now includes a dedicated set of Zustand-based stores to manage state and persistence. This introduces a centralized Hugging Face token store that handles migration from legacy local storage keys, synchronizes tokens across browser tabs, and persists credentials to the backend. A new Hub Feed store manages the trending and latest model feeds with token-aware caching and throttled local storage persistence. Additionally, an external link confirmation store provides a mechanism to prompt users before navigating to external URLs, and a cross-tab inventory event system ensures consistent state updates across open Studio tabs.

studio/frontend/src/features/hub/stores · high confidence

A new WebUpdateBanner component has been added to the Studio frontend to notify users of available updates. This banner displays the current and latest version numbers, provides a toggleable panel to view release notes sourced from the official changelog, and offers platform-specific installation commands (PowerShell for Windows, shell script for macOS/Linux/WSL) that can be copied to the clipboard. The UI includes options to dismiss or snooze the notification and is designed to scale with the interface font size without clipping buttons.

studio/frontend/src/components/web · high confidence

The model picker now supports saving and applying distinct settings for each model, including context length, KV cache dtype, speculative decoding, and chat template overrides. A new Model Config page provides granular controls for these parameters, while a Memory Estimate row displays real-time VRAM and RAM usage predictions with detailed breakdowns. Users can also edit custom Jinja chat templates via a dedicated editor with size limits and validation, and a Numeric Value Input component ensures precise, step-aware entry for all numeric settings.

studio/frontend/src/features/model-picker/components · high confidence

The Studio frontend now supports persistent, server-synced profile customization, including display name, nickname, avatar selection (from a curated set of sloth emojis), theme, palette, and language preferences. A new \useEffectiveProfile\ hook resolves the user-facing display name by prioritizing the nickname, then the display name, and finally the login ID (with special casing for the 'unsloth' owner ID to display as 'Unsloth'). Profile usage statistics are now loaded and refreshed via a dedicated hook that handles aborts and background status changes. These changes ensure that user identity and appearance settings are consistent across sessions and surfaces.

studio/frontend/src/features/profile/hooks · high confidence

Added new utility modules in the profile feature to support avatar display, image handling, and statistics formatting. The \avatar-initials\ module provides logic to generate initials from user names and applies theme-aware accent colors for avatar backgrounds. The \resize-image-file\ module handles client-side image compression, preserving transparency for PNG/WebP uploads and using JPEG for opaque images, ensuring files fit within storage limits. The \stats-format\ module introduces locale-aware formatting for profile statistics, supporting compact number notation (e.g., 1.2K, 1.2万) and proper pluralization for units like tokens, messages, and steps across multiple languages.

studio/frontend/src/features/profile/utils · high confidence

The Studio now detects when a model requires a newer version of the \transformers\ library than the one currently installed in the sidecar. When this occurs, a consent dialog appears, offering to install the latest PyPI release of \transformers\ to support the new architecture. If no released version supports the model, or if the model includes custom modeling code, the dialog offers a fallback to continue using the existing \transformers\ version with custom code enabled.

studio/frontend/src/features/transformers-upgrade · high confidence

The Recipe Studio canvas now includes dedicated floating control panels for layout and viewport management. Users can auto-layout the graph, toggle between left-to-right and top-to-bottom direction, zoom in/out, fit the view to content, and toggle full-screen maximization. An interaction lock feature allows users to freeze the canvas during complex operations. Additionally, a new floating bar provides direct access to Run and Check (validate) actions, supporting both preview and full execution kinds, with visual feedback for busy/locked states. These controls are backed by new utility components for syncing node internals and consistent fit-view behavior.

studio/frontend/src/features/recipe-studio · high confidence

Recipe Studio can now import recipes that include complex configurations for LLM inference (including trace modes, reasoning content extraction, and image context), model providers (with local and remote endpoints, extra headers/body, and health checks), data samplers (category, uniform, gaussian, bernoulli, datetime, uuid, and person types with conditional parameters), seed sources (Hugging Face, local files, unstructured uploads, and GitHub repositories with selection strategies), and code validators (including OXC-based linting and validation modes). These new parsers ensure that imported recipes correctly reconstruct the full configuration state for these components, enabling users to reuse sophisticated data generation and validation setups across sessions.

studio/frontend/src/features/recipe-studio/utils/import/parsers · high confidence

Recipe Studio now includes a comprehensive set of frontend utilities for managing block configurations and graph interactions. The new \config-factories.ts\ provides factory functions to create typed configurations for samplers (category, uniform, gaussian, bernoulli, datetime, timedelta, uuid, person), LLMs, expressions, validators, and seeds. \config-type-guards.ts\ adds TypeScript type guards to safely identify these node types. \validation.ts\ enforces block-specific rules, such as requiring at least two values for category samplers, valid ranges for numeric samplers, and mandatory model aliases for LLMs. \graph-warnings.ts\ detects and reports graph issues, including disconnected nodes, missing data sources for LLMs, and invalid subcategory parent references. \layout.ts\ implements automatic graph layout using dagre, respecting pipeline ranks and layout directions. \handles.ts\ defines and normalizes connection handles for data, semantic, and LLM lanes, supporting both left-right and top-bottom layouts. \node-data.ts\ maps configurations to user-facing node titles and subtypes. \refs.ts\ handles Jinja reference extraction and validation. \image-preview.ts\ supports previewing images from base64, URLs, and byte arrays. \model-provider-types.ts\ defines supported provider types (OpenAI-compatible, Anthropic). \ui-tones.ts\ provides consistent styling tokens for different block types. These utilities collectively enhance the Recipe Studio's ability to configure, validate, and visualize complex data pipelines.

studio/frontend/src/features/recipe-studio/utils · high confidence

The Recipe Studio frontend now uses a dedicated, modular payload builder to construct and validate recipe execution data before sending it to the backend. This change introduces specific support for new configuration types, including LLM trace modes and reasoning content extraction, MCP provider configurations (stdio and streamable HTTP), and OXC-based code validation for JavaScript/TypeScript. It also expands seed source options to include GitHub repositories and unstructured file uploads with server-side chunking, while adding validation for sampler types like datetime, timedelta, and UUID formats. Users benefit from stricter client-side validation that catches configuration errors—such as missing model aliases, invalid provider endpoints, or mismatched validator targets—before execution.

studio/frontend/src/features/recipe-studio/utils/payload · high confidence

The Recipe Studio frontend now supports a broader range of node types and configuration options. New node kinds include \model\_provider\, \model\_config\, and \tool\_config\, enabling infrastructure and tool management within recipes. The system introduces validator blocks supporting Python, SQL, and OXC (JavaScript/TypeScript) with specific modes like syntax checking and linting. Additionally, seed sources now include GitHub repositories, and sampler types have been extended to include datetime, timedelta, UUID, and person generation. LLM configurations now support structured, code, and judge types, along with MCP provider integration for tool calling.

studio/frontend/src/features/recipe-studio/types · high confidence

The studio/backend directory is introduced, establishing the core runtime for the Unsloth Studio application. This includes platform compatibility fixes for Anaconda Python environments, a Cloudflare tunnel module for secure public access, Colab integration helpers, and a LAN access listener for local network discovery. It also adds a ModelScope router to serve models from that platform via the Hugging Face API, a System One decision-model runtime for Laya, and the main FastAPI application entry point with hardware detection and environment setup.

studio/backend · high confidence

The Studio backend now includes a new \studio/backend/utils\ package containing core utility modules. This adds an \account\_context\ module for managing per-request account identity across async and threaded execution, and \api\_errors\ to standardize error envelopes for OpenAI and Anthropic-compatible API surfaces. It also introduces \audio\_tokens\ for classifying audio model types via tokenizer fingerprints, \auth\_safe\ for secure credential handling during redirects, and \cache\_cleanup\/\cache\_inventory\ for managing compiled model caches. Additionally, \client\_ip\ handles trusted proxy IP resolution for rate limiting, \code\_integrity\ detects Windows code integrity blocks, and \coding\_agents\ detects installed coding agent CLIs.

studio/backend/utils · high confidence

The Studio backend now includes a new state management layer in \studio/backend/state\ to support advanced agentic and multi-user features. This adds a registry for tracking in-flight chat generations (\active\_generations.py\) to handle tab closures and parallel chats, a subscriber tracking system (\run\_subscribers.py\) to detect when users are actively watching a run, and a per-call tool-confirmation gate (\tool\_approvals.py\) that allows users to approve or deny tool executions with timeout and 'parking' logic for unattended runs. Additionally, a server-side tool policy module (\tool\_policy.py\) enforces global or per-request tool enablement settings, ensuring consistent behavior across different client interfaces.

studio/backend/state · high confidence

The chat interface has been significantly restructured and expanded. A new \ApiProviderLogo\ component now renders provider-specific icons with dark-mode inversion. Attachment handling is overhauled with dedicated adapters for audio files and comprehensive content extraction for PDFs, DOCX, HTML, and OpenDocument formats. The chat experience now includes a Blender MCP setup wizard, a bypass-permissions menu for tool access, and a full MCP server management dialog. The main chat page has been rewritten to integrate these features, alongside project scoping, guided tours, and native intent support.

studio/frontend/src/features/chat · high confidence

The Studio frontend has been restructured to support a native desktop experience (Tauri) with a new application shell. This includes a new router configuration with an improved 404 fallback, robust authentication guards that handle session validation and password-change flows, and a dedicated provider that manages desktop-specific UI elements like startup screens, update banners, and window layout constraints. The app now features a macOS-native menu system with configurable keyboard shortcuts and accelerators, and implements precise window management logic to handle sizing, centering, and monitor work-area constraints on first launch and subsequent sessions.

studio/frontend/src/app · high confidence

The Studio frontend now supports 12 display languages (English, Simplified Chinese, Japanese, Korean, Spanish, Portuguese (Brazil), French, German, Italian, Russian, Hindi, and Arabic). The UI dynamically loads language catalogs on demand rather than bundling all translations at startup, and includes a parity-check tool to ensure translation keys and placeholders match across locales. Users can select their preferred language, which is persisted in the browser, or let the app auto-detect the system locale.

studio/frontend/src/i18n · high confidence

The Studio frontend application is established with a new React entry point (main.tsx) and a comprehensive CSS architecture (index.css) built on Tailwind and shadcn. This update introduces a redesigned sidebar with draggable resizing, scroll-edge fade effects, and a collapsible icon rail, alongside a new interface scaling system that allows users to adjust UI font size and spacing. It also adds type definitions for Vite asset imports and the Web Speech API to support local speech-to-text dictation, while initializing locale and interface scale settings before the first paint to prevent layout shifts.

studio/frontend/src · high confidence

The Studio component is now released under the AGPL-3.0 license, with the license text and copyright headers added to the package. This change also introduces documentation for new Studio capabilities: an opt-in local Model Context Protocol (MCP) server for external tool integration, a Blender MCP integration for 3D workflow automation, support for OCR on scanned PDFs via Tesseract, and specific guidance for running ROCm on RDNA2 APUs like the Steam Deck.

studio · high confidence

The Studio training workflow has been reorganized into dedicated components: a new dataset picker (\dataset-picker\) that unifies selection from local files, Hugging Face cache, and Hub search; a historical training viewer (\historical-training-view\) that displays past runs with sparkline charts and resume capabilities; and a live training view (\live-training-view\) that tracks real-time progress, charts, and download states. These changes improve dataset selection clarity, provide persistent access to training history, and enhance real-time monitoring with better state reconciliation and display logic.

studio/frontend/src/features/studio · high confidence

The training feature in the Studio frontend is now backed by a dedicated API layer and robust state management. This includes new modules for Hugging Face token validation and warning dialogs to handle authentication securely, and a full set of API clients for datasets (format checking, uploading, AI-assist mapping), training history (listing, deleting, renaming), and model configuration (vision/embedding checks, local model listing). The training start payload builder has been refined to correctly map UI settings to backend requirements, including handling of 4-bit loading, custom dataset mappings, and specific model types. Additionally, a new hook for toggling between max steps and epochs modes with local storage persistence, and a training actions hook for managing start, stop, and resume workflows, provide a more stable and user-friendly training configuration experience.

studio/frontend/src/features/training · high confidence

The Studio backend now uses a centralized hardware detection module that identifies CUDA, ROCm, MLX, and Intel XPU devices, while providing accurate VRAM estimation for training jobs. This includes detailed accounting for model weights, LoRA adapters, optimizer states, gradients, and activations, with specific support for multi-GPU setups and various attention implementations. The change also introduces AMD NPU detection and Apple Silicon GPU monitoring, ensuring that users get reliable hardware information and training resource estimates across different platforms.

studio/backend/utils/hardware · high confidence

The Unsloth desktop app for macOS now includes native File, View, Go, and Help menus with keyboard shortcuts, allowing users to navigate directly to settings, projects, and the model hub from the menu bar. The app also requests microphone access for local voice dictation and persists the main window's size and maximized state across launches for a consistent layout. These changes are supported by new macOS entitlements for network access, unsigned executable memory, and audio input, as well as a build script to ensure the aarch64 Windows toolchain is available during compilation.

studio/src-tauri · high confidence

A new security module in the Studio backend now protects model loads by scanning for remote code execution vectors and unsafe files. Before enabling \\trust\_remote\_code\\, the system statically scans the model repository's \\auto\_map\\ for suspicious patterns (such as network access, subprocess calls, or credential theft) and requires explicit user consent, pinning approvals to a content fingerprint so that code changes trigger a re-prompt. Additionally, a file security gate checks Hugging Face's security scan status to block models containing flagged pickle weight files that could execute code during deserialization, even when remote code is disabled. These checks apply to both local and remote models, ensuring that only verified, user-approved code is executed during training or inference.

studio/backend/utils/security · high confidence

The Studio frontend directory is initialized with a new project structure, including a Vite-based entry point, ESLint and Biome configuration, and shadcn/ui component setup. To address supply-chain security concerns, an .npmrc file enforces a 7-day minimum release age for packages and pins the default npm registry, while a .gitignore file excludes build artifacts and local environment files.

studio/frontend · high confidence

The chat hooks in the Studio frontend have been reorganized from a single monolithic file into separate, dedicated modules (e.g., \use-chat-audio-upload\, \use-chat-model-runtime\, \use-chat-projects\, \use-chat-search-index\, \use-chat-sidebar-items\, \use-pill-activation-order\, \use-rag-tool-disabled\, \use-sidebar-drag\, \use-transfer-stats\). This change improves code maintainability and separation of concerns by isolating specific chat functionalities—such as audio transcription, model loading, project management, search indexing, sidebar interactions, and transfer statistics—into their own files.

studio/frontend/src/features/chat/hooks · high confidence

The Data Recipe backend routes have been reorganized from a single monolithic file into distinct modules for seed inspection, validation, job management, and MCP tooling. This structural change improves code readability and maintainability by separating concerns, while preserving the existing API surface and authentication logic for users interacting with data recipes.

_studio/backend/routes/data\recipe · high confidence

The Studio backend now uses a dedicated \studio/backend/models\ package to define Pydantic schemas for all API request and response bodies. This change centralizes validation and typing for core features including model loading and inference, training job management, model export (GGUF, merged, LoRA), authentication (JWT login, refresh, password change), external provider configuration, MCP server management, and data recipe/dataset handling. Users benefit from stricter input validation, consistent API contracts, and improved reliability across these Studio capabilities.

studio/backend/models · high confidence

The Studio backend's model handling logic has been consolidated into a new \studio/backend/utils/models\ package, replacing scattered implementations with a structured module. This change introduces \model\_config.py\ for comprehensive model identification, including GGUF variant parsing, audio/vision capability detection, and size extraction; \gguf\_metadata.py\ for efficient, cached reading of GGUF headers; \checkpoints.py\ for scanning training outputs and inferring base models from run history; and \model\_identity.py\ to normalize Hugging Face cache paths into standard repository IDs. Additionally, \unsloth\_mirror.py\ provides a parser for Unsloth's internal model mapping tables, enabling the Studio to correctly resolve public mirror repositories for gated or quantized models.

studio/backend/utils/models · high confidence

The model service logic in the Studio backend has been reorganized from a monolithic structure into a set of dedicated modules (account\_access, cache\_inventory, catalog\_classification, common, companion\_cleanup, deletion, downloads, folder\_browser, and gguf\_variants). This change improves code maintainability and separation of concerns by isolating account boundary checks, cache scanning, model classification, deletion logic, and download orchestration into their own files, while preserving the existing product behavior for model management.

studio/backend/hub/services/models · high confidence

The backend API endpoints are now organized into a dedicated \studio/backend/routes\ package. This change introduces a central \\_\init\\_.py\ that aggregates and re-exports routers for all major Studio features—including training, models, inference, video, datasets, authentication, data recipes, export, history, providers, MCP servers, skills, RAG, research, and YouTube integration. It also adds new route modules for account lifecycle management (\accounts.py\) and a comprehensive authentication system (\auth.py\) that handles login, password changes, API keys, and desktop-specific authentication flows.

studio/backend/routes · high confidence

The Studio training backend has been reorganized into a set of focused modules to improve maintainability and separation of concerns. This change introduces dedicated modules for account-based job isolation and path validation (account\_jobs), precise row bounding for max\_steps training runs (dataset\_bounds), and resumable checkpointing for diffusion models (diffusion\_checkpoint). It also adds specialized training loops and dataset handling for new capabilities, including flow-matching DiT families (diffusion\_dit\_trainer), MiniMax-H3 joint video and audio LoRA training (diffusion\_h3\_clips, diffusion\_h3\_trainer), and clip-based dataset discovery (diffusion\_clip\_formats). These modules collectively provide the core infrastructure for the Studio's updated training workflows, including multi-user security, efficient data loading, and support for complex multimodal models.

studio/backend/core/training · high confidence

A change to existing behaviour in studio/src-tauri/icons — 4 commits, 9 files.

studio/src-tauri/dmg, studio/src-tauri/icons · medium confidence · unverified

The \unsloth\cli\ package has been restructured to improve reliability and cross-platform support. On Windows, the CLI now automatically reconfigures console streams to UTF-8 to prevent encoding errors during help text and output rendering, and it detects when the process is running from system directories like System32, moving the working directory to a safe user location before execution. A new \\\main\\_.py\ module allows running the CLI via \python -m unsloth\_cli\ as a fallback for environments where the generated console script is blocked by security policies. Additionally, the CLI now supports the \-np\<N\>\ flag for specifying the number of parallel slots, and includes a new \\_tool\_policy\ module to resolve server-side tool access rules based on network binding addresses.

_unsloth\cli · high confidence

The Deep Research module now includes dedicated logic to prevent the model from inventing or misformatting citations, ensuring that only URLs and document references actually gathered during the run appear in the final report. It also introduces strict redaction of private data (credentials, PII, tokens) from search queries and escapes prompt-delimiter tags in untrusted evidence to prevent instruction injection. Additionally, the system now parses and validates structured model outputs (plans, actions, audits) more robustly and can inject the current date into prompts to improve recency handling.

studio/backend/core/research · high confidence

The download manager now survives page reloads and navigation by persisting active download state to local storage. This ensures that model and dataset downloads initiated in the Hub continue running in the background even if the user navigates away or refreshes the page, with the UI automatically re-adopting and displaying the correct progress, speed, and ETA upon return. The implementation includes robust handling for transport selection (HTTP vs. Xet), generation tracking to distinguish new runs from resumed ones, and specific logic to handle scoped downloads and companion files without blocking fresh downloads of deleted variants.

studio/frontend/src/features/hub/download-manager · high confidence

The repository now enforces consistent line endings across different operating systems to prevent script failures and signature invalidation. Python files, shell scripts, and frontend sources are normalized to LF, while PowerShell installers and vendored documentation assets are kept as-is to preserve Authenticode signatures and binary integrity. Additionally, a pre-commit configuration is introduced to automate monthly dependency updates and enforce code formatting, ensuring that autofix commits do not break due to executable bit issues.

(repo-wide) · high confidence

The Hub feature area now uses a suite of new React hooks to manage model discovery and selection. Infinite scroll behavior is governed by a new policy engine (\hub-infinite-scroll-policy\) that distinguishes between resets and visible result updates. Model and dataset searches are handled by dedicated hooks (\use-hub-model-search\, \use-hub-dataset-search\) that support paginated fetching, sorting, and error classification. A new \useHubFeed\ hook manages the trending feed with its own retry and backoff logic, while \useDiscoverSearch\ coordinates these sources and handles network availability states. Selection logic is centralized in \useModelsSelection\, which resolves the active model across discover, cached, and local inventory rows. Additional hooks provide supporting capabilities like dataset size fetching, VRAM estimation, and clipboard feedback.

studio/frontend/src/features/hub/hooks · high confidence

The Unsloth Studio Linux AppImage now bundles a complete runtime to prevent crashes caused by host library conflicts, specifically addressing COLRv1 font issues by using a private 'Unsloth Safe Emoji' font and isolating GTK/GIO modules. The AppImage launcher also clears inherited environment variables to ensure consistent behavior. Additionally, a new polkit policy file enables authenticated in-app updates for Debian package installations.

studio/src-tauri/linux · high confidence

The Windows desktop installer now includes custom hooks to prevent leftover files from breaking upgrades and ensures user data in the profile directory is preserved during uninstall. To reduce antivirus false positives, the installer template loads signed NSIS plugins and signs the final binaries using Azure Trusted Signing with automatic retry logic for transient authentication errors.

studio/src-tauri/windows · high confidence

The export feature now includes a robust runtime lifecycle hook that maintains a persistent log stream with automatic reconnection and a JSON polling fallback, ensuring users see real-time progress even over unstable connections like Cloudflare tunnels. Additionally, a new size estimation hook fetches the model's real FP16/BF16-equivalent size to provide accurate GGUF file size predictions for the selected quantization.

studio/frontend/src/features/export/hooks · high confidence

The Studio backend now uses a dedicated subprocess worker (studio/backend/hub/workers/hf\_download.py) for HuggingFace model downloads. This change ensures reliable resume capabilities by enforcing single-stream sequential writes and restoring huggingface\_hub's 1.17 append-mode writer behavior, preventing data loss when downloads are interrupted. It also integrates native OS trust store verification for TLS connections, improving security in corporate proxy environments, and includes a parent-death watchdog to cleanly terminate orphaned download processes.

studio/backend/hub/workers · high confidence

The backend picker now validates and manages chat templates on a per-model basis. It enforces a 64 KiB size limit and checks for valid Jinja syntax (including support for the \{% generation %}\ tag) when templates are submitted or loaded, rejecting malformed or excessively large inputs. This ensures that user-provided or model-specific templates are safe and renderable before they are applied to the model configuration.

studio/backend/picker · high confidence

The backend now loads model-specific inference parameters (temperature, top\_p, top\_k, min\_p, presence\_penalty, and trust\_remote\_code) by prioritizing a model's own YAML config, then falling back to family-level defaults defined in inference\_defaults.json, and finally to a global default.yaml. This ensures that the sampling values applied by the server match the recommendations shown in the UI. Additionally, operators can enforce global sampling limits via UNSLOTH\SAMPLING\\* environment variables, which take precedence over model-specific recommendations, and the system validates all values to prevent invalid inputs from reaching the inference server.

studio/backend/utils/inference · high confidence

The Studio backend now centralizes the rules for discovering, pairing, and ranking speculative drafter sidecars (MTP, DSpark, and DFlash) in a new \studio/backend/utils/models/drafters\ module. This change ensures that drafter selection is consistent across local scans, remote downloads, and cache lookups by applying shared naming conventions, precision-based preference keys, and strict budgeting logic to prevent VRAM exhaustion. Users benefit from more reliable automatic drafter detection and safer resource management when speculative decoding is enabled.

studio/backend/utils/models/drafters · high confidence

The model picker now uses dedicated policy modules to enforce runtime constraints and improve selection accuracy. Audio models are filtered by codec compatibility (e.g., rejecting undecodable CSM GGUFs) and routed correctly to the Audio page. Host capabilities are classified (e.g., 'dense-quant' vs 'gguf-only') to determine which diffusion pipelines and quantization schemes are offered. A new catalog system groups model variants and validates integrity. Additionally, connected models now have dedicated dialogs to view metadata (context window, max output, reasoning capabilities) and manage per-model settings (system prompt, output cap, reasoning effort).

studio/frontend/src/features/model-picker/components/model-selector · high confidence

The Studio frontend now uses a dedicated API client for export operations, introducing a custom \ExportRequestError\ that distinguishes between authoritative backend rejections (4xx) and recoverable transport failures (5xx/524), allowing the UI to retry or poll status on transient network issues. This client exposes functions for fetching checkpoints, estimating export sizes, and initiating exports for merged models, base models, GGUF (including imatrix and multiple quantization methods), and LoRA adapters (with optional GGUF conversion), while securely passing Hugging Face tokens via headers to prevent leakage in URLs or logs.

studio/frontend/src/features/export/api · high confidence

The Studio frontend now includes dedicated configuration files (\env.ts\, \hardware-verdict.ts\, \training.ts\) that centralize platform detection, hardware capability gating, and training hyperparameters. \env.ts\ introduces a \usePlatformStore\ to track device type (mac, windows, linux) and Apple Silicon status, fetching authoritative hardware verdicts from the backend \/api/health\ endpoint with a polling mechanism to handle warm-up delays. \hardware-verdict.ts\ defines logic to interpret backend health responses, distinguishing between provisional, deferred, and resolved hardware states to determine if the UI should restrict features (e.g., hiding Train/Video on unsupported hardware). \training.ts\ consolidates training defaults, including context lengths, target modules (with specific handling for Continued Pretraining/CPT), optimizer options for both PyTorch and MLX backends, and default hyperparameters like learning rates and LoRA settings.

studio/frontend/src/config · high confidence

The Hub's on-device model and dataset inventory has been rebuilt to consolidate scanning from multiple local sources (Hugging Face cache, LM Studio, Ollama, Hermes, and custom folders) into a unified view. This change introduces a new inventory API and state management layer that tracks partial and resumable downloads, deduplicates entries across sources, and provides real-time download status updates to the user interface.

studio/frontend/src/features/hub/inventory · high confidence

The resource picker in the Studio frontend has been replaced with a new implementation that supports switching between local device and Hub resources via a segmented control. This new picker includes keyboard navigation, pagination with a 'Load More' button, and improved error handling for authentication, rate limits, and network issues. It also introduces new utility functions for validating Hub resource IDs, resolving device picker items, and displaying dataset and path names.

studio/frontend/src/components/resource-picker · high confidence

The Studio settings UI now uses dedicated Zustand stores to manage user preferences, introducing granular control over the interface. Users can now customize the sidebar navigation by pinning and reordering items (such as Hub, Projects, Library, and Media tabs) and controlling which menu items appear in the profile dropdown. A new interface scaling setting allows users to adjust the UI size from 50% to 200% via a slider or keyboard shortcuts, with the scale persisting across sessions. Additionally, a comprehensive keyboard shortcuts store enables users to view, bind, and rebind chords for all actions, with conflict detection to prevent overlapping keys. The theme system has been refactored to support distinct color palettes (Standard, Classic, Minimal) and respects system dark mode preferences, while embedding model settings are now centralized to prevent conflicts between the General and Data tabs.

studio/frontend/src/features/settings/stores · high confidence

The Studio now automatically migrates locally stored Hugging Face tokens and external provider API keys to the backend for persistent storage. On startup, the application reconciles any legacy local credentials with the server, saving them to the backend while cleaning up the local copies. This ensures that credentials are preserved across sessions and devices, and the UI will no longer rely on local storage for these sensitive values.

studio/frontend/src/features/credentials, studio/frontend/src/features/hub/api · high confidence

The Studio frontend now applies the stored theme (light/dark mode and palette) and custom appearance settings (fonts, contrast, UI scale) immediately upon load, before the main application bundle executes, ensuring the first paint reflects the user's preferences. Additionally, a snapshot mechanism captures and restores the page state—including inline styles, CSS tokens, and imported fonts—during navigation or reloads to prevent the interface from flashing blank or resetting to default styles.

studio/frontend/public · high confidence

The Recipe Studio interface has been redesigned with a new set of React components that modernize the visual style and interaction model. The block sheet now supports drag-and-drop block creation and includes a search feature for easier navigation. The graph canvas features updated node and edge components with consistent styling, rounded corners, and improved visual feedback for active and selected states. A new chip input component provides a better experience for entering multiple values with suggestions. The header has been updated to include a workflow name editor, view tabs (Easy/Advanced/Runs), and a warnings popover. These changes collectively provide a more polished and consistent user experience within the Recipe Studio.

studio/frontend/src/features/recipe-studio/components · high confidence

The Recipe Studio canvas now uses new helper modules to manage node connections and positioning more robustly. Edge synchronization (edge-sync.ts) automatically updates connections when node configurations change, such as switching a model provider, updating a model alias, or modifying sampler references. Layout handling (model-infra-layout.ts) now intelligently places new nodes to avoid overlapping existing ones and respects the configured layout direction. Node updates (node-updates.ts) ensure visual consistency by applying the current layout direction to node data, while reference management (reference-sync.ts) and removal logic (removals.ts) correctly clean up internal references and edges when nodes are renamed or deleted.

studio/frontend/src/features/recipe-studio/stores/helpers · high confidence

The Recipe Studio frontend now centralizes core workflow logic into a set of dedicated React hooks within the \hooks\ directory. \use-recipe-studio-actions\ acts as the primary orchestrator, combining \use-recipe-executions\ (which manages job creation, cancellation, and progress tracking) and \use-recipe-persistence\ (which handles saving, importing, and sanitizing shared payloads). \use-recipe-editor-graph\ manages the visual graph interactions, including drag-and-drop and node changes, while \use-node-connection-status\ provides real-time validation of node connectivity. \use-recipe-runtime-visuals\ handles the dynamic display of execution states and icons. This refactoring replaces the previous monolithic implementation with a modular, maintainable structure.

studio/frontend/src/features/recipe-studio/hooks · high confidence

The Recipe Studio graph utility layer has been restructured into modular components to improve maintainability and support new visual behaviors. The new \derive-display-graph.ts\ module centralizes the logic for normalizing edge handles, styling active edges, and handling layout direction, ensuring consistent visual representation of data and semantic flows. A new \fit-view.ts\ utility standardizes the auto-fit behavior, explicitly excluding decorative markdown notes and auxiliary LLM overlay nodes from the viewport calculation to prevent unwanted zooming. Connection logic in \recipe-graph-connection.ts\ has been enhanced to support template references, validate validator code languages (OXC, Python, SQL), and manage single-reference relations for model and tool configurations. Additionally, \runtime-visual-state.ts\ introduces live execution tracking, highlighting active nodes and edges based on real-time execution status and upstream dependencies.

studio/frontend/src/features/recipe-studio/utils/graph · high confidence

The Hub catalog now features a redesigned card carousel with drag-to-scroll and arrow navigation, alongside a comprehensive overhaul of the download experience. Users benefit from clearer network error states that distinguish between browser offline status and server timeouts, and a new 'Free up space' dialog that safely identifies and removes orphaned shared model assets (like text encoders and VAEs) that are no longer needed by any installed model. The catalog also introduces a 'Delete impact' preview that truthfully reports how much disk space will actually be freed versus retained, and adds a 'ModelScope' source option for model discovery.

studio/frontend/src/features/hub/catalog · high confidence

The tool profile dialog has been refactored to support managing tools by provider, introducing a new UI for configuring MCP (Model Context Protocol) servers. Users can now add and manage multiple providers, choosing between 'Local command' (stdio) and 'HTTP endpoint' (streamable\_http) transport types. The interface includes detailed configuration sections for server names, command arguments, and environment variables, along with logic to validate provider readiness and collect tool suggestions based on the configured providers.

studio/frontend/src/features/recipe-studio/dialogs/tool-profile · high confidence

The chat runtime logic has been refactored into a modular architecture, introducing dedicated API modules for chat adapters, generation tracking, and settings persistence. This change improves the reliability of chat sessions by enabling durable, server-owned generation runs that survive tab closures and network interruptions, while also streamlining how chat preferences and inference parameters are synchronized with the backend.

studio/frontend/src/features/chat/api · high confidence

The chat interface state has been reorganized from a monolithic structure into a set of specialized Zustand stores, improving reliability and feature support. Chat preferences (such as thinking visibility, tool call permissions, and inline actions) are now persisted to localStorage, ensuring settings survive page refreshes. Navigation state, including the sidebar's pinned, project, and recent lists, is centralized to keep the UI consistent and support features like keyboard-based chat switching. Runtime configuration, including GPU memory, speculative decoding, and external provider settings, is now managed in a dedicated store with robust persistence and migration logic. Additionally, new stores handle specific UI states like the prompt queue, research run progress, fork boundaries, and sidebar drag-and-drop organization, providing a more stable foundation for complex interactions.

studio/frontend/src/features/chat/stores · high confidence

The execution handling in Recipe Studio has been restructured into dedicated modules (helpers, hydration, run-settings, runtime, and tracker) to consolidate how executions are created, tracked, and displayed. This change introduces support for naming full runs, enhances execution log tracking with formatted event lines, and adds batch processing configuration options (batch size, merge batches, parallel requests) that are now normalized and applied to the execution payload. Users will see improved status mapping, better sorting of execution records, and more robust handling of dataset pagination and progress updates during both preview and full runs.

studio/frontend/src/features/recipe-studio/executions · high confidence

The Studio backend now provides more accurate download progress tracking by correctly distinguishing between finalized and incomplete cache blobs, ensuring that partial downloads do not incorrectly report as complete or stall at 99%. Additionally, a new safety check prevents destructive operations (like deletion) from targeting the wrong model version when cached repository IDs differ only by letter casing, raising a clear error instead of risking data loss.

studio/backend/hub/services · high confidence

The Train Model Picker has been completely rewritten to provide a more robust and scalable model selection experience. This change introduces a new component architecture (including \TrainModelSelector\, \TrainModelDeviceList\, and \TrainModelHubList\) that handles both local and Hub-based model discovery. Key improvements include better detection of models downloaded by Hermes, support for VRAM estimation and fit status visualization for selected models, and a refined UI with proper pagination, error handling, and search capabilities. The new implementation also standardizes how model metadata (like format and pipeline tags) is validated and displayed, ensuring a consistent experience across different model sources.

studio/frontend/src/features/train-model-picker · high confidence

The prompt storage interface has been redesigned into a master-detail layout, allowing users to manage prompt entries and lists with a dedicated detail pane. This change introduces robust mutation locking to prevent race conditions during asynchronous saves, ensuring that edits are not overwritten by stale drafts. It also adds support for reordering items via drag-and-drop with smooth animations, and expands export capabilities to include JSONL and CSV formats for both individual and bulk prompt operations.

studio/frontend/src/features/chat/prompt-storage · high confidence

The export runtime store now implements a status-recovery mechanism to handle cases where the initial export request is interrupted by network issues (such as Cloudflare tunnel timeouts) while the backend operation continues. If the POST request fails, the UI automatically polls the export status endpoint to monitor the ongoing backend task, ensuring that users can still track progress and receive the final result without losing their export job. This change improves reliability for long-running exports in unstable network conditions.

studio/frontend/src/features/export/stores · high confidence

The Studio backend now serves the Swagger UI and ReDoc documentation interfaces using local static files rather than loading them from an external CDN. This change bundles \swagger-ui-dist\ (v5.30.2) and \redoc\ (v2.5.1) directly into the application, ensuring the documentation pages work offline and preventing the frontend from accessing user session tokens stored in \localStorage\ via inline scripts. The specific assets, including JavaScript bundles, CSS, and license files, are now managed locally in the \studio/backend/assets/docs\_ui\ directory and verified by SHA-256 hashes.

_studio/backend/assets/docs\ui · high confidence

The Settings dialog has been re-architected to improve performance and usability. Tab panels are now lazy-loaded on demand rather than at launch, reducing initial startup time. A new low-disk space warning system monitors available storage and alerts users when space is critically low, pointing them to cache management. The dialog also now displays the desktop application version (via Tauri) and includes a comprehensive search index to help users quickly find settings across all tabs.

studio/frontend/src/features/settings · high confidence

The Studio assistant UI components have been replaced with a new implementation that introduces several user-facing changes. Users can now preview attached images, audio, and text files directly in the chat composer via a dedicated attachment preview system, with large text files handled efficiently to avoid page freezes. A new chat dictation bar provides a live waveform visualization for voice input, allowing users to record, stop, and send audio directly. Additionally, code fence syntax highlighting is now deferred by default, meaning off-screen code blocks render as plain text shells until they near the viewport, significantly improving chat performance for long threads without changing the visual appearance of highlighted code.

studio/frontend/src/components/assistant-ui · high confidence

The Studio backend logging system has been rewritten to use \structlog\ for structured JSON output, replacing previous ad-hoc logging. This change significantly reduces log noise by deduplicating repetitive access logs (such as health checks and UI polls) and suppressing successful progress updates for media generation and downloads, while still emitting clear, milestone-based progress events. Additionally, the new logging middleware sanitizes sensitive data, truncates excessively long exception messages to prevent log flooding, and escapes unprintable or potentially malicious Unicode characters in tracebacks to ensure log integrity and security.

studio/backend/loggers · high confidence

The Studio chat interface now uses a dedicated set of utility modules in the chat library to manage model loading, inference status, and parameter persistence. This includes logic to correctly identify when a model is resident versus merely selected, handle GPU placement and offloading for GGUF and MLX models, and persist per-model inference settings (such as temperature and sampling parameters) so they are remembered across model switches. The update also introduces a context usage bar that accurately reflects token consumption against the context window, providing specific advice for different model backends like llama.cpp and MLX, and adds support for tracking cache-miss downloads and reasoning effort levels.

studio/frontend/src/features/chat/lib · high confidence

The chat utilities in the Studio frontend have been reorganized into a set of dedicated modules to improve reliability and feature support. This includes new logic for handling archived chat exports, local GGUF auto-compaction, and automatic continuation of interrupted runs. Chat history is now managed with robust cross-tab synchronization, revision tracking, and storage in the backend database (with a legacy import path). The system also supports importing chats from various formats (Studio backups, Open WebUI, OpenAI/ShareGPT JSONL, CSV), searching history with performance hints, and persisting per-model chat settings and presets. Additional improvements include better handling of chat attachments (deletion events, audio uploads), generation recovery, and thread creation claims to ensure data integrity across view switches.

studio/frontend/src/features/chat/utils · high confidence

The dataset processing backend in studio/backend/utils/datasets has been reorganized from a single monolithic file into focused modules (format\_detection, format\_conversion, chat\_templates, vlm\_processing, data\_collators, model\_mappings, and others) to improve maintainability. This change introduces a robust audio decoding fallback using soundfile and PyAV when torchcodec is unavailable (particularly on Windows), ensuring audio datasets load correctly. It also adds a permission-safe dataset loading mechanism (cache\_safe.py) that retries loads in an Unsloth-owned cache directory if the shared Hugging Face cache is unreadable or if Windows symlink privileges fail. Additionally, the refactoring includes new utilities for detecting None/empty content in conversation datasets, handling completion-only masking via auto-detection or template tables, and providing specialized data collators for speech, OCR, and VLM training.

studio/backend/utils/datasets · high confidence

The Studio frontend has migrated its routing to TanStack Router, introducing a structured route tree that includes a root layout, an index redirect, and dedicated routes for Chat, Images, Video, Audio, Hub, Library, Data Recipes, Export, Settings, and API monitoring. A key behavioral change is the persistent mounting of the Chat, Images, Video, and Audio pages within the root layout; this ensures that in-flight generations or active sessions are preserved and not cancelled when users navigate away from these tabs. All routes are protected by authentication guards, and the root layout now handles global concerns like low disk warnings, personalization syncing, and chat settings hydration. The Settings route now acts as a deep-link trigger that opens the settings modal and redirects the user, while the index route automatically redirects authenticated users to their appropriate post-auth destination.

studio/frontend/src/app/routes · high confidence

The Studio frontend now includes new build scripts to enforce performance budgets and manage model data. The \check-bundle-budget.ts\ script monitors the JavaScript download and execution size before the first screen renders, ensuring the startup bundle stays within defined transfer and raw byte limits. A new \build-fast-copy-bundle.mjs\ script compiles the \thread-fast-copy\ module into a standalone IIFE for testing purposes. Additionally, \refresh-model-catalog-snapshot.mjs\ automatically updates the local model catalog snapshot from the models.dev API, and \coal-span-census.mjs\ provides a utility to analyze code fence tokenization for styling consistency.

studio/frontend/scripts · high confidence

The Studio frontend components have been significantly refactored and expanded to support a redesigned user interface. Key additions include a new draggable sidebar (\app-sidebar.tsx\) with enhanced project and chat management, a floating resource monitor (\floating-monitor.tsx\) with stable docking logic, and a new \AdvancedDisclosure\ component for settings. The update introduces a unified \GalleryItemMenu\ for media management, a \CodeSourceView\ for code display, and a \LazyImportBoundary\ for improved error handling. Additionally, new components like \ImageDropzone\, \HelpActions\, and \MascotImg\ enhance media handling, user support, and visual feedback, while \AppReadiness\ and \AppPortalGate\ manage application state and portal visibility more effectively.

studio/frontend/src/components · high confidence

The frontend library has been reorganized into a collection of specialized modules to improve code maintainability and feature support. New capabilities include robust multi-account isolation logic for browser data, a budgeted LRU cache for authenticated gallery media, and refined audio attachment handling with specific MIME and extension support. The update also introduces a unified clipboard utility that prioritizes native Tauri IPC and handles Safari's gesture requirements, alongside a new floating panel ordering system to manage overlapping monitors. Additionally, the diff adds utilities for parsing data URIs, normalizing dense quantization schemes, tracking desktop update states, and resolving diffusion model GGUF filenames, while also standardizing error formatting for FastAPI responses.

studio/frontend/src/lib · high confidence

The Studio frontend hooks have been restructured to improve GPU memory reporting, dataset split handling, and preflight error messaging. GPU memory calculations now correctly distinguish between dedicated VRAM and shared host memory (including unified memory on ROCm APUs and shared memory on Windows), ensuring accurate VRAM totals and fit checks. Dataset split loading now supports local, remote, and Hub sources with normalized error messages for better user guidance. Preflight messages provide clearer instructions for stale installs, unresolvable paths, and quarantined llama.cpp runtimes. Additional hooks manage server stop intents across webview reloads, GPU utilization polling, and UI layout adjustments like chat settings width and composer pill fitting.

studio/frontend/src/hooks · high confidence

The Studio settings interface has been restructured into a tabbed layout, replacing the previous single-page or grouped view with distinct tabs for About, Accounts, Agents, API Keys, Appearance, Chat, Connections, Data, Debugging, and General. This change improves navigation and organization by grouping related configuration options into their own dedicated sections, making it easier for users to find and manage specific settings.

studio/frontend/src/features/settings/tabs · high confidence

The Studio export engine has been refactored to run model conversions in a persistent background subprocess. This change allows the system to switch between different transformers versions without restarting the main process and prevents export operations from timing out or hanging the UI. Users now see real-time progress updates streamed directly into the export dialog, and the system provides better handling for multi-GPU setups and network interruptions during model loading.

studio/backend/core/export · high confidence

The Studio backend now routes GGUF model inference through the /v1/chat/completions API endpoint instead of the legacy /v1/completions endpoint. This change aligns the GGUF inference path with the standard chat protocol, ensuring consistent behavior for chat-based interactions and tool usage.

studio/backend/core/inference · high confidence

The validator configuration dialog in the Recipe Studio has been updated to support advanced OXC (Oxidation Compiler) validation options. Users can now select specific validation modes (such as syntax checking or linting) and code shapes when configuring OXC-based validators. The dialog also includes logic to filter available target code steps based on the validator type, ensuring that only compatible JavaScript/TypeScript steps are shown for OXC validators, while Python and SQL steps are available for other validator types.

studio/frontend/src/features/recipe-studio/dialogs/validators · high confidence

Studio now displays a non-blocking toast when a model loads that would benefit from higher integrated GPU memory allocation. The notice includes the backend-generated explanation and a "Don't show again" action that records the dismissal on the server, ensuring the advice does not reappear on subsequent loads or after origin changes.

studio/frontend/src/features/igpu-carveout · high confidence

Corrects a bug in the LlamaModel fast-forward inference path where the model configuration's torch\_dtype was not being handled correctly, ensuring that the data type is properly preserved during inference.

unsloth · high confidence

The Studio export feature now distinguishes warning messages from standard output and error streams. Log entries matching specific known warning patterns (such as deprecated PyTorch arguments or incompatible extension versions) are now styled with a warning indicator, while stderr remains red and status messages remain blue. This helps users quickly identify non-critical issues during the export process without being overwhelmed by standard output.

studio/frontend/src/features/export/lib · high confidence

Added test coverage for Studio Hub backend services; Added unit tests for Studio account authentication and session management; Expanded test coverage for Studio and backend stability; Expanded test coverage for Studio backend functionality.

This change introduces the foundational dependency manifests for the Unsloth Studio ecosystem. It adds \pyproject.toml\ and \package.json\ files for the main Unsloth Python package, the JupyterLab extension (\unsloth-jupyterlab\), and the Studio frontend, establishing version constraints for core libraries such as PyTorch, FastAPI, React, and Tauri. It also includes the Rust \Cargo.toml\ and \Cargo.lock\ for the Tauri-based desktop application, the OXC validator runtime dependencies (\oxc-parser\, \oxlint\), and seed plugin manifests for the Data Designer, ensuring all build and runtime requirements are explicitly defined for the first time.

(dependencies) · high confidence

Studio now uses a unified dependency resolution strategy (single-env) that installs Unsloth, Studio, and Data Designer in the same Python environment. This change introduces a new set of constraint and override files to pin specific versions of core libraries—such as transformers, huggingface-hub, tokenizers, and anyio—to ensure compatibility across platforms (including macOS ARM64, Windows ARM64, and Windows ROCm) and Python versions. It also includes a metadata patching script to resolve conflicting dependency declarations between Data Designer and the Unsloth stack, ensuring a stable and consistent runtime experience without requiring separate virtual environments.

studio/backend/requirements/single-env · high confidence

The Studio backend dependency configuration has been consolidated from a flat list into a modular, single-environment structure under \studio/backend/requirements/\. This new system uses distinct files (\base.txt\, \extras.txt\, \extras-no-deps.txt\, \no-torch-runtime.txt\, \diffusers-pin.txt\, etc.) to manage shared, audio, non-torch, and specific library constraints, ensuring reproducible installs across different Python versions and platforms (including Windows ARM64 and macOS). Key updates include pinning \diffusers\ to 0.40.0 for release stability while supporting a pinned \diffusers-main\ commit for bleeding-edge models like Qwen-Image-2.1, upgrading \openai\ to 3.2.0 for Python 3.10+ (with 2.48.0 for 3.9), and adding support for new capabilities such as S3 dataset loading (\boto3\), local speech-to-text (\openai-whisper\, \av\), and RAG features (\sqlite-vec\, \pymupdf\).

studio/backend/requirements · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 39 → 50 (+11.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 73 → 65 (-8.7)
• Architecture 41 (new)
• Maturity 50 → 56 (+6.1)
• Readiness 27 → 59 (+32.4)
• Security 43 → 64 (+21.1)
• Accessibility 55 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• FileTooLong: oxc-validator/validate.mjs (studio/backend/core/data_recipe/oxc-validator/validate.mjs)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High CVE: [GHSA redacted] (studio/frontend/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 71 more

• (anonymous)::restoreSnapshot (cyclomatic 19) (studio/frontend/public/reload-snapshot.js)
• (anonymous)::saveSnapshot (cognitive 37) (studio/frontend/public/reload-snapshot.js)
• (anonymous)::saveSnapshot (cyclomatic 34) (studio/frontend/public/reload-snapshot.js)
• ActiveGeneration.enter (cognitive 17) (studio/backend/state/active_generations.py)
• AnthropicMessage._normalize_content (cognitive 30) (studio/backend/models/inference.py)
• AnthropicPassthroughEmitter.feed_chunk (cognitive 51) (studio/backend/core/inference/anthropic_compat.py)
• AnthropicPassthroughEmitter.feed_chunk (cyclomatic 32) (studio/backend/core/inference/anthropic_compat.py)
• AnthropicStreamEmitter._route_text (cognitive 66) (studio/backend/core/inference/anthropic_compat.py)
• AnthropicStreamEmitter._route_text (cyclomatic 24) (studio/backend/core/inference/anthropic_compat.py)
• ApiMonitor.accumulate_openai_tool_call (cognitive 28) (studio/backend/core/inference/api_monitor.py)
• ApiMonitor.accumulate_openai_tool_call (cyclomatic 24) (studio/backend/core/inference/api_monitor.py)
• ApiMonitor.append_reply (cognitive 17) (studio/backend/core/inference/api_monitor.py)
• ApiMonitorEntry.snapshot (cognitive 17) (studio/backend/core/inference/api_monitor.py)
• ApiMonitorEntry.snapshot (cyclomatic 18) (studio/backend/core/inference/api_monitor.py)
• ApiUsageWriter._run (cognitive 20) (studio/backend/storage/api_usage_db.py)
• Change coupling clique: audio-page.tsx, images-page.tsx, video-page.tsx (studio/frontend/src/features/audio/audio-page.tsx)
• Change coupling: api.ts ↔ runtime.ts (studio/frontend/src/features/chat/types/api.ts)
• Change coupling: cache_inventory.py ↔ chat-api.ts (studio/backend/hub/services/models/cache_inventory.py)
• Change coupling: chat-adapter.ts ↔ chat-settings-storage.ts (studio/frontend/src/features/chat/api/chat-adapter.ts)
• Change coupling: chat-page.tsx ↔ thread-sidebar.tsx (studio/frontend/src/features/chat/chat-page.tsx)
• …and 6411 more

• 300 commits — 278 feature/other, 22 fixes

• studio/backend — 107 commits
• studio/frontend — 83 commits
• tests/studio — 35 commits
• unsloth/models — 14 commits
• .github/workflows — 7 commits
• (root) — 4 commits
• .github/scripts — 4 commits
• tests/saving — 4 commits
• tests/python — 3 commits
• (repo) — 2 commits
• studio/src-tauri — 2 commits
• tests/kaggle — 2 commits
• tests/test_image_processing_reexports.py — 2 commits
• tests/version_compat — 2 commits
• unsloth/_version.py — 2 commits
• docker/unsloth_pip_shim.py — 1 commit
• docker/unsloth_studio_update.sh — 1 commit
• scripts/lint_exec_literals.py — 1 commit
• scripts/scan_packages_baseline.json — 1 commit
• studio/install_node_prebuilt.py — 1 commit

• fix: CI: fix path filters that miss dependencies, and narrow three that are too broad (#11989)
• fix: Fix Code tool placement for ChatGPT subscriptions (#11628)
• fix: Fix GGUF vision capability selection (#11696)
• fix: Fix PEFT base export targets silently exporting the base model (#11781)
• fix: Fix false ONNX rejection for models with native weights (#11695)
• fix: Fix left-padded Online DPO scoring during training (#11885)
• fix: Fix text_only 4-bit load and generate for Gemma-4 and other VLM text configs (#11684)
• fix: Format the two files #11526 left off the formatter's fixed point (#11955)
• fix: Revert "Studio: steady the Images and Video loading spinners, and tidy the pr…" (#11691)
• fix: Studio: fix broken Chinese, Japanese and emoji text in gpt-oss replies (#11720)
• fix: Studio: fix document search for embedding models other than the default (#11853)
• fix: Studio: fix login failures during slow startup (#11289)
• fix: Studio: fix pinned rows in the model picker (#11943)
• fix: fix(grpo): use the evaluated model's output head for log-probs (#11877)
• fix: fix(studio): classify MLX requests from the applied chat template override (#11903)
• fix: fix(studio): keep Stop generating visible while queuing (#9123)
• fix: fix(studio): recover from a dead Metal GPU queue instead of failing every later request (#11383)
• fix: fix(studio): retain GGUF quants across cache-folder switches (#11938)
• fix: fix(studio): show compaction notices for tool-loop checkpoints (#11702)
• fix: fix(studio): support preserve thinking for llama.cpp connections (#11706)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

unslothai/unsloth 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.