Skip to content
CAI
Software that uses CAICheck a score

mudler/LocalAI

47.8

Weak · 13 November 2026

509.2k

lines of production code

Go

with JavaScript

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add ACE-Step music generation backend

Introduces a new gRPC-based backend for ACE-Step 1.5 music generation, enabling users to generate audio from text prompts, lyrics, or metadata. The implementation includes a Python service (backend.py) that handles model loading, audio sample creation, and formatting, along with installation scripts, a Makefile for build/test management, and unit tests to verify health, model loading, and sound generation capabilities.

backend/python/ace-step · high confidence

Add AceStep C++ backend for text-to-music generation

This change introduces a new backend for LocalAI that integrates the AceStep C++ library to generate music from text prompts. The implementation includes a Go wrapper and C++ bindings that load multiple GGUF models (a language model, text encoder, DiT model, and VAE) to produce audio output. The backend supports various CPU instruction sets (AVX, AVX2, AVX512) on Linux and Metal on macOS, with build scripts and packaging logic to handle these variants. It exposes a gRPC interface for loading models and generating sound, allowing users to specify parameters like BPM, duration, and lyrics.

backend/go/acestep-cpp · high confidence

Add Anthropic Messages API endpoint with tool calling and thinking support

Introduces a new HTTP endpoint at /v1/messages that implements the Anthropic Messages API specification. This allows clients to interact with models using Anthropic's message format, including support for tool/function calling and interleaved 'thinking' (reasoning) blocks. The implementation converts incoming Anthropic requests to the internal OpenAI-compatible format, injects Model Context Protocol (MCP) tools when configured, and handles both streaming and non-streaming responses while correctly mapping Anthropic-specific features like reasoning content and tool use events.

core/http/endpoints/anthropic · high confidence

Add Apple Silicon MLX video generation backend

A new gRPC-based video generation backend is introduced for macOS on Apple Silicon, supporting LTX-2 and converted Wan2.1/Wan2.2 MLX checkpoints. The service exposes model loading, video generation, and health-check endpoints, enforcing platform requirements and rejecting unsupported features like audio conditioning. It is managed via standard Makefile targets (install, run, test) and includes unit tests for model classification and command building.

backend/python/mlx-video · high confidence

Add Bonsai backend build and runtime infrastructure

Introduces the build system and runtime scripts for the Bonsai backend, which uses a PrismML llama.cpp fork to support Q1\_0 (1-bit) and Q2\_0 (ternary) weight quantizations. The new Makefile provides targets for various CPU instruction sets (AVX2, AVX512, AVX, fallback) and a unified CPU\_ALL\_VARIANTS build, while applying necessary patches to ensure compatibility with the reused gRPC server. The run.sh script handles binary selection, ROCm TensileLibrary path configuration, and Intel Level Zero driver loading to ensure correct execution across different hardware environments.

backend/cpp/bonsai · high confidence

Add CED sound-event classification backend

A new sound-event classification backend (CED) is now available, allowing users to detect and tag audio content using the ced.cpp model. This change introduces the Go-based gRPC server implementation (main.go, goced.go) that binds to the libced.so shared library via purego, along with build scripts (Makefile, package.sh) and runtime helpers (run.sh) to manage the C++ dependency and packaging. Users can now load CED-compatible GGUF models to perform audio tagging via the SoundDetection gRPC endpoint.

backend/go/ced · high confidence

Add Chatterbox TTS backend with multilingual support and text chunking

Introduces a new gRPC-based TTS backend for Chatterbox, enabling text-to-speech generation via a dedicated server. This backend supports multilingual synthesis and automatically splits long input texts into manageable chunks to prevent processing errors, merging the resulting audio segments into a single output file. It includes installation scripts that handle dependency isolation to avoid conflicts, and provides a test suite to verify server startup, model loading, and TTS functionality.

backend/python/chatterbox · high confidence

Add ElevenLabs Sound Generation and TTS API endpoints

New HTTP handlers have been added to expose ElevenLabs-compatible audio generation capabilities. The \SoundGenerationEndpoint\ allows users to generate audio from text with support for parameters like duration, temperature, and instrumental mode, while the \TTSEndpoint\ provides a text-to-speech interface compatible with the ElevenLabs API structure. These endpoints integrate with the existing backend model loading and audio normalization logic to return generated audio files.

core/http/endpoints/elevenlabs · high confidence

Add GEM-X motion capture backend with duplex streaming

A new GEM-X backend is introduced for motion capture, providing a native C++ inference engine (pinned to localai-org/gem-x.cpp commit 756f6b3) wrapped in a Go gRPC server. This backend supports duplex streaming of motion data, allowing clients to send video frames and receive skeleton poses in real-time. It handles model loading for GEM, ViTPose, and YOLOX components, supports CPU and Vulkan devices, and exposes configuration options for thread count, detection cadence, and precision. The implementation includes image projection logic for mapping 3D joints to 2D screen coordinates and validates input frames to ensure data integrity before processing.

backend/go/gemxcpp · high confidence

Add Go client for the vector store API

A new \StoreClient\ implementation in Go has been added to the \core/clients\ package, enabling programmatic interaction with the store API. This client supports standard vector store operations including setting key-value pairs, retrieving values by keys, deleting keys, and finding similar vectors (top-k search) against a configurable base URL.

core/clients · high confidence

Add Jina-style reranking API endpoint

A new HTTP endpoint has been added to support the Jina reranker API specification, allowing users to rerank a list of documents based on their relevance to a given query. This change introduces the \JINARerankEndpoint\ handler which processes requests, validates parameters like \top\_n\, and delegates the actual reranking logic to the backend, returning results in the Jina-compatible response format.

core/http/endpoints/jina · high confidence

Add Kokoro TTS backend

Introduces a new gRPC-based text-to-speech backend using the Kokoro pipeline, allowing users to generate audio with an 82-million-parameter model that supports multiple languages and voice options. The implementation includes a Python server (backend.py) that handles model loading and TTS requests, along with installation scripts that pre-download the required spaCy phonemization model to ensure runtime compatibility, and a test suite to verify service health and audio generation.

backend/python/coqui, backend/python/kokoro, backend/python/mlx-audio · high confidence

Add Kokoros TTS backend

Introduces a new Kokoros text-to-speech backend for the Rust backend area. This includes the build configuration (Makefile, build.rs) to compile the gRPC service from protobuf definitions, a packaging script (package.sh) that bundles the binary, dynamic libraries, espeak-ng data, and SSL certificates for portability, and a runtime script (run.sh) to execute the service with the correct library paths. The submodule for the Kokoros source code has been updated to commit 29e99ad.

backend/rust · high confidence

Add LongCat Video backend for text-to-video and avatar generation

Introduces a new Python gRPC backend for Meituan's LongCat-Video and LongCat-Video-Avatar-1.5 models, enabling text-to-video, image-to-video, and audio-driven avatar generation. The backend includes a Makefile to fetch and patch the upstream source with a PyTorch SDPA attention fallback for systems lacking optional kernels, and supports configuration options for attention backends, resolution, and model variants.

backend/python/longcat-video · high confidence

Add MLX-VLM backend for multimodal vision-language model inference

Introduces a new MLX-VLM backend implementation that enables the platform to load and run multimodal vision-language models using the MLX framework. This backend supports gRPC-based model loading and prediction, including multimodal inputs (images and audio), tool-use parsing, and reasoning content extraction, along with the necessary installation, execution, and test scripts to integrate it into the existing backend infrastructure.

backend/python/mlx-vlm · high confidence

Add MOSS-TTS C++ text-to-speech backend

Users can now generate speech using the MOSS-TTS-Local (v1.5) model via a new C++ backend. This backend runs the model through moss-tts.cpp, producing 48 kHz stereo WAV output without requiring Python at inference time. It supports voice cloning via reference audio paths and allows configuration of the transformer, audio codec, and text tokenizer GGUFs. The backend includes build scripts for various CPU architectures (AVX, AVX2, AVX512) and GPU backends (CUDA, HIP, Metal, Vulkan, SYCL).

backend/go/moss-tts-cpp · high confidence

Add Magpie TTS C++ backend for multilingual text-to-speech

This location introduces the Go wrapper and build infrastructure for the Magpie TTS C++ backend, enabling text-to-speech synthesis using NVIDIA's Magpie TTS Multilingual 357M model via the magpie-tts.cpp library. The backend loads the model as a shared library (libgomagpiettscpp) and exposes a C-API interface for synthesis, supporting 5 baked voices (Aria, Jason, John, Leo, Sofia) and 12 languages. It outputs 22.05 kHz mono 16-bit PCM WAV files, with streaming support that emits a self-describing WAV header followed by PCM chunks. The build system (Makefile/CMakeLists.txt) handles GPU acceleration (CUDA, ROCm/HIP, Metal, Vulkan, SYCL) and CPU optimizations (AVX, AVX2, AVX512) via variant-specific shared libraries. The Go code handles voice/language resolution, case-insensitive matching, and error handling, while tests verify synthesis output and streaming behavior.

backend/go/magpie-tts-cpp · high confidence

Add Moonshine gRPC backend for faster transcription

Introduces a new Moonshine backend that exposes a gRPC service for audio transcription, allowing users to load models and transcribe audio files with timing segments. This includes the backend implementation, build/install scripts, and unit tests to verify server startup, model loading, and transcription accuracy.

backend/python/moonshine · high confidence

Add NVIDIA NeMo ASR backend with word-level timestamp support

Introduces a new gRPC-based backend for NVIDIA NeMo Automatic Speech Recognition, enabling users to transcribe audio using models like nvidia/parakeet-tdt-0.6b-v3. This backend supports word-level timestamps, allowing for granular timing information in transcription results, and includes installation, testing, and runtime scripts to facilitate deployment. The implementation handles model loading from local snapshots or Hugging Face, supports CUDA and MPS devices, and provides a health check endpoint for service monitoring.

backend/python/nemo · high confidence

Add NeuTTSAir gRPC backend for text-to-speech

Introduces a new gRPC-based backend service for NeuTTSAir, enabling text-to-speech generation with support for voice cloning via reference audio. The implementation includes a Python server (backend.py) that handles model loading and inference, utilizing PyTorch for device detection (CUDA, MPS, CPU) and integrating with the neutts-air library. The change also adds build and test infrastructure (Makefile, install.sh, run.sh, test.sh) to manage dependencies, start the service, and run unit tests for health checks, model loading, and TTS functionality.

backend/python/neutts · high confidence

Add OmniVoice C++ TTS backend with voice cloning and streaming

Introduces a new text-to-speech backend powered by the ServeurpersoCom/omnivoice.cpp library, accessible via a Go wrapper. This backend supports file-based synthesis and streaming audio output, and enables voice cloning (using reference audio) and voice design (using instructions). It includes build infrastructure for various CPU instruction sets (AVX, AVX2, AVX512) and GPU backends (CUDA, HIP, Metal, Vulkan, SYCL), along with e2e tests verifying WAV generation and streaming chunk delivery.

backend/go/omnivoice-cpp · high confidence

Add Pocket TTS backend support

A new Pocket TTS backend has been added to the system, providing a gRPC-based service for text-to-speech generation. This implementation includes a Python backend server that supports loading models on CPU, CUDA, or MPS devices, caching voice states, and generating audio output. The addition comes with a Makefile for build and run management, installation scripts handling dependencies (including specific configurations for Intel and L4T profiles), and a comprehensive test suite verifying server startup, model loading, and TTS generation with both HuggingFace voice URLs and default voices.

backend/python/pocket-tts · high confidence

Add Qdrant vector store backend

Introduces a new Qdrant-based vector store implementation for LocalAI. This backend supports TLS 1.2 connections with configurable CA certificates and skip-verify options, and allows configuration of the distance metric (Cosine, Euclid, Dot, Manhattan) with warnings for non-Cosine metrics. Upsert operations are performed in chunks of 500 points with individual request timeouts to prevent long-running requests, and the store automatically creates collections if they do not exist.

backend/go/qdrant-store · high confidence

Add Qwen3-ASR local speech recognition backend

Introduces a new gRPC-based backend for the Qwen3-ASR model, enabling local speech-to-text transcription. The implementation includes device selection logic that supports CUDA, Intel XPU, and MPS hardware, along with a language mapping layer that translates ISO 639-1 codes (e.g., 'de', 'zh') into the full language names required by the Qwen3-ASR library. The package comes with shell scripts for installation and execution, a Makefile for build management, and unit tests for device utility functions and end-to-end server health and model loading.

backend/python/qwen-asr · high confidence

Add SAM3-CPP vision backend for point, box, and text-prompted segmentation

This change introduces a new C++-based backend for the SAM3 segmentation model, enabling users to perform image segmentation using point prompts, box prompts, or text prompts (PCS mode). The backend wraps the PABannier/sam3.cpp library (version 416186c) and exposes it via a Go wrapper that communicates over gRPC. It supports multiple CPU instruction set variants (AVX, AVX2, AVX512) on Linux and includes Metal support for macOS. Users can now load SAM3 models and detect objects with associated bounding boxes, confidence scores, and PNG-encoded masks.

backend/go/sam3-cpp · high confidence

Add Silero VAD Go backend with macOS support

This change introduces a new Go-based backend for Silero Voice Activity Detection (VAD), providing a standalone gRPC server implementation. The backend now supports macOS (Darwin) in addition to Linux, handling architecture-specific ONNX runtime library packaging and dynamic library path configuration via the new Makefile and run.sh scripts. Users can now utilize this dedicated backend for VAD tasks, which loads the Silero detector and exposes speech segment detection capabilities through the standard gRPC interface.

backend/go/silero-vad · high confidence

Add Supertonic ONNX TTS backend

Users can now use the Supertonic ONNX Text-to-Speech backend for local voice synthesis. This new Go-based backend supports CPU and CUDA execution providers, enabling high-quality speech generation with configurable voice styles, languages, and synthesis parameters (steps, speed, silence). It includes streaming support and handles model loading via the standard LocalAI gRPC interface.

backend/go/supertonic · high confidence

Add VibeVoice backend with TTS and ASR support

Introduces a new gRPC-based backend for VibeVoice, enabling both Text-to-Speech (TTS) and Automatic Speech Recognition (ASR) capabilities. The backend loads models such as \microsoft/VibeVoice-Realtime-0.5B\ for TTS and \microsoft/VibeVoice-ASR\ for transcription, supporting streaming inference and configurable options like device selection (CUDA/MPS/CPU), voice presets, and generation parameters. Includes installation scripts, a Makefile for build/test/run workflows, and unit tests for the gRPC service endpoints.

backend/python/vibevoice · high confidence

Add VoxCPM TTS backend with streaming and voice cloning support

A new gRPC-based backend for the VoxCPM text-to-speech model has been added to the system. This integration enables users to generate audio using the VoxCPM1.5 model, featuring support for both standard and streaming generation modes, as well as voice cloning capabilities via prompt audio and text. The implementation includes a Python service that handles model loading on CUDA, MPS, or CPU devices, applies a specific patch to resolve PyTorch compatibility issues in the attention module, and pins setuptools to ensure stable dependency resolution. A comprehensive test suite is included to verify model loading and streaming functionality.

backend/python/voxcpm · high confidence

Add Voxtral audio transcription backend

Introduces a new backend for audio transcription using the Voxtral model. This change adds the Go wrapper, C/C++ integration code, and build scripts (CMake/Makefile) required to load Voxtral models and perform transcription via gRPC. It includes platform-specific optimizations, such as Metal support on macOS and AVX/AVX2 variants on Linux, along with packaging scripts to bundle the necessary shared libraries.

backend/go/voxtral · high confidence

Add Whisper-Medusa speech recognition backend

A new local AI backend for Whisper-Medusa speech recognition has been added to the system. This component implements a gRPC service that handles audio transcription, supporting automatic device selection (CUDA, MPS, or CPU), audio preprocessing (resampling to 16kHz, mono conversion), and configurable inference parameters such as language and exponential decay length penalty. The backend includes a default model reference ('aiola/whisper-medusa-linear-libri') and is packaged with installation, build, and test scripts to facilitate deployment.

backend/python/whisper-medusa · high confidence

Add WhisperX backend for transcription with speaker diarization

Introduces a new Python-based gRPC backend for WhisperX, enabling audio transcription with word-level timestamps, forced alignment, and speaker diarization. The implementation includes a dedicated server (\backend.py\) that loads WhisperX models, handles audio processing, and manages alignment caching. It supports device selection (CPU, CUDA, MPS) and requires an Hugging Face token (\HF\_TOKEN\) to enable the gated diarization pipeline, rejecting requests if the token is missing when diarization is requested. The change also adds build scripts (\install.sh\, \protogen.sh\, \run.sh\), a Makefile for managing the environment, and unit tests to verify server startup, model loading, and transcription functionality.

backend/python/whisperx · high confidence

Add chat context compression service

A new context compression service has been added to automatically summarize long chat histories to fit within model context limits. The service compresses older conversation turns into a single summary message while preserving system instructions and the most recent messages (including active tool calls). It includes configurable policies for triggering compression, token budgets, and overflow recovery strategies, along with OpenTelemetry metrics to track compression events, ratios, and duration.

core/services/compression · high confidence

Add faster-qwen3-tts voice cloning backend

A new gRPC-based backend for the Faster Qwen3-TTS model has been added to the system, enabling voice cloning capabilities. This component provides a CUDA-dependent inference service that loads the Qwen3-TTS model and generates audio from text using a reference voice sample, exposing Health, LoadModel, and TTS endpoints for integration.

backend/python/faster-qwen3-tts · high confidence

Add faster-whisper backend for speech-to-text

A new faster-whisper backend has been added to the speech-to-text capabilities, providing a gRPC-based service that leverages the faster-whisper library for transcription. This backend supports device selection (CPU, CUDA, and MPS) and enables word-level timestamp granularity in the transcription output. The implementation includes specific installation logic for ROCm environments via CTranslate2 wheels and enforces a 50MB gRPC message size limit.

backend/python/faster-whisper · high confidence

Add llama.cpp backend with speculative decoding and VRAM management

This change introduces a new GRPC-based backend for llama.cpp models, enabling users to run inference via the LocalAI server. The implementation supports speculative decoding through draft models, allowing for potential performance improvements, and includes a dedicated Free method to properly release GPU VRAM when models are unloaded. It also exposes various model loading options such as context size, LoRA adapters, and RoPE frequency settings.

backend/go/llm · high confidence

Add locate-anything-cpp backend for open-vocabulary object detection

Introduces a new C++-based backend that enables open-vocabulary object detection using the locate-anything.cpp library (ggml). This addition includes the Go gRPC handler for loading GGUF models and running detection, a CMake build system for compiling the native library with CPU feature variants (AVX, AVX2, AVX512) and macOS Metal support, and end-to-end smoke tests to verify the detection pipeline.

backend/go/locate-anything-cpp · high confidence

Add prompt templates for Alpaca, Koala, Llama 2, Vicuna, and other models

New prompt templates have been added to the prompt-templates directory to support specific model formatting requirements. These include templates for Alpaca, Koala, Vicuna, WizardLM, and GPT4All-J, as well as a specific template for Llama 2 chat messages that handles system prompts and role-based content. A generic 'getting\_started' template is also included. These files define the input/output structures used by the application when interacting with these respective models.

prompt-templates · high confidence

Add rfdetr-cpp native object detection and segmentation backend

Introduces a new C++-based backend for LocalAI that provides object detection and instance segmentation capabilities using the rf-detr.cpp library. This change adds the Go gRPC server implementation (gorfdetrcpp.go, main.go) which loads the native shared library via purego and exposes detection endpoints. It also includes the build infrastructure (CMakeLists.txt, Makefile) to compile the backend with support for various CPU instruction sets (AVX, AVX2, AVX512) and GPU backends (CUDA, Metal, ROCm), along with smoke tests to verify detection and segmentation functionality.

backend/go/rfdetr-cpp · high confidence

Add trellis2cpp backend for 3D generation

This change introduces a new backend in \backend/go/trellis2cpp\ that integrates the \localai-org/trellis2cpp\ C++ library (pinned to commit \2f3e6e26edbbaaf8ce93d092f16f46968a366a6a\) to enable 3D model generation. The Go implementation provides gRPC bindings to the native library, handling model resolution for the required GGUF components, CPU variant selection (AVX/AVX2/AVX512/fallback), and GLB mesh parsing for print remeshing. It includes build scripts for packaging the shared libraries and tests for model path resolution and parameter mapping.

backend/go/trellis2cpp · high confidence

Add vLLM-Omni backend for multimodal generation

Introduces a new vLLM-Omni backend that enables multimodal capabilities including text-to-image, image editing, text-to-video, image-to-video, text generation with multimodal inputs, and text-to-speech. The backend exposes a gRPC interface, handles model loading and type detection, and includes installation scripts for various build profiles (CUDA 12, CUDA 13, ROCm, and L4T aarch64) along with unit tests for service startup and image generation.

backend/python/vllm-omni · high confidence

Add-on contract and proposal flow model

This change introduces the foundational contract package for the new add-on system, defining the version-one manifest schema, runtime wire protocols (envelopes, receipts, previews), host operation channels, and tool definitions with strict validation rules. It also adds a formal state-machine model for the add-on proposal flow, specifying states, events, and invariants to ensure safe execution of user-initiated actions.

pkg · high confidence

Added NATS payload types for distributed MCP tool execution

The \core/services/mcp\ package now includes \remote.go\, which defines the request and response structures for executing and discovering MCP tools via NATS in a distributed mode. These types (\MCPToolRequest\, \MCPToolResponse\, \MCPDiscoveryRequest\, \MCPDiscoveryResponse\) enable the serialization of model configurations and tool definitions between agents and workers, supporting the underlying infrastructure for remote tool execution.

core/services/mcp · high confidence

Added internal versioning and user-agent identification

The internal package now exposes version metadata (Version and Commit) and a UserAgent function that constructs a client identity string for outbound requests. This string includes the LocalAI version (if available) and the OS/architecture platform, allowing registries and galleries to distinguish between source builds and released versions in logs. Tests verify that the user-agent correctly formats these details.

internal · high confidence

Automated inference defaults generation with HTTP redirect refusal

A new tool in core/config/gen\_inference\_defaults fetches and validates inference parameter defaults from the Unsloth repository, remapping field names (e.g., repetition\_penalty to repeat\_penalty) and filtering to a specific set of allowed fields (temperature, top\_p, top\_k, min\_p, repeat\_penalty, presence\_penalty) before writing the result to core/config/inference\_defaults.json. The tool uses the local HTTP client which now refuses outbound redirects, ensuring that the fetch operation is hardened against redirect-based attacks or unexpected location changes.

_core/config/gen\_inference\defaults · high confidence

Bounded backend trace history with audio quality metrics

The backend now captures and persists a bounded history of backend operations (LLM, TTS, transcription, etc.) in the admin Traces UI. To keep the UI responsive, trace payloads are capped (defaulting to 1 MB per trace body) and oversized string values in the Data field are truncated with a marker. Audio traces now include quality metrics (RMS, peak, DC offset) and a base64-encoded WAV snippet of the first 30 seconds, with the snippet dropped if it exceeds the body cap. Traces are persisted to disk and restored on restart, and non-finite float values (like -Inf dBFS for silence) are sanitized to ensure valid JSON responses.

core/trace · high confidence

Cloud proxy now supports PII redaction via TLS interception

The cloud proxy service now includes a man-in-the-middle (MITM) component that intercepts traffic to allowlisted LLM API hosts. It dynamically generates and caches TLS certificates to decrypt requests, applies NER-based PII redaction to request bodies (masking or blocking sensitive data like emails and secrets), and then forwards the sanitized traffic to the upstream. This ensures that sensitive user data is not sent to external providers while maintaining transparent proxying for non-intercepted hosts.

core/services/cloudproxy · high confidence

Experimental tinygrad backend for LLMs and multimodal tasks

A new experimental backend powered by tinygrad has been added to the Python backends directory. It enables LLM text generation (supporting models like Qwen3, Llama 3.x, and GLM-4 via GGUF and HuggingFace safetensors), embeddings, Stable Diffusion 1.x image generation, and Whisper audio processing. The backend includes native tool-call extraction for various model families (Hermes, Llama 3, Mistral, Qwen 3) and handles device selection for CUDA, HIP, and CPU (via LLVM) environments.

backend/python/tinygrad · high confidence

Failover service introduces chain management, health probing, and cross-instance state synchronization

The failover service now manages model chains with automatic failover, recovery, and pinning capabilities. It classifies errors to distinguish between retryable failures and capability gaps, probes remote targets via HTTP and local targets via gRPC to monitor health, and schedules liveness and inference checks to drive fail-back decisions. State is synchronized across multiple frontends using a leader-gated architecture to ensure consistent chain decisions and target health status.

core/services/failover · high confidence

Federated P2P mode with load balancing and worker targeting

The core/p2p package now includes a new federated server implementation that allows users to distribute requests across multiple P2P nodes. This change introduces a \FederatedServer\ that supports two routing strategies: random selection for basic distribution or least-connection load balancing to optimize resource usage. Users can also explicitly target a specific worker node via configuration. The implementation handles node discovery, connection proxying, and request tracking to ensure efficient load distribution within the P2P network.

core/p2p · high confidence

Formal verification specs for realtime and model-loader lifecycles

Added authoritative FizzBee formal specifications and a pinned FizzBee v0.5.2 toolchain to the \formal-verification\ directory. The specs cover the realtime API state machines (connection, turn detection, response coordination, conversation compaction, and TTS pipeline) and the shared model-loader shutdown lifecycle. These models serve as the source of truth for design verification, ensuring that implementation changes are checked against invariants such as single-flight compaction, idempotent teardown, and coupled speech/turn states.

formal-verification · high confidence

Interactive local-ai chat mode with local server management

Users can now run \local-ai chat\ to start an interactive terminal session with a LocalAI model. The CLI automatically probes for a running server, and if none is found, it prompts the user to start a local server in the background. It handles model selection by auto-picking a single available model or prompting the user to choose one when multiple are installed, persisting that choice for future runs. The session respects terminal signals for clean shutdown and manages the local server lifecycle, ensuring it stops when the chat session ends.

core/cli/chat · high confidence

Introduce C++ ds4 backend with DSML streaming parser and disk KV cache

Added a new C++ backend for the ds4 (DeepSeek V4 Flash) model that implements a streaming DSML parser to correctly handle thinking-mode reasoning and tool-call structures, a renderer for tool-call and manifest formatting, and a disk-based KV cache for session persistence. The backend is built via CMake and Makefile targets (grpc-server and ds4-worker) supporting CPU, CUDA, and Metal execution paths, and includes unit tests for the parser and generation-limit logic.

backend/cpp/ds4 · high confidence

Introduce CrispASR backend with multi-architecture support and word-level timestamps

The new CrispASR backend in \backend/go/crispasr\ provides a unified Go service for both automatic speech recognition (ASR) and text-to-speech (TTS). It bundles a C++ shim (\crispasr\_shim\) that links against the CrispASR library and GGML, enabling support for a wide range of models including parakeet, canary, qwen3, f5-tts, and piper. The backend is built with multi-architecture optimizations (AVX, AVX2, AVX512, fallback) and includes word-level timestamp accessors for supported models. It also handles TTS voice selection, voice cloning via reference WAVs, and correctly writes WAV files at the native sample rate for piper voices.

backend/go/crispasr · high confidence

Introduce Kokoros gRPC backend with optional Bearer token authentication

Adds a new Rust-based gRPC backend for the Kokoros TTS engine, exposing standard backend operations such as health checks, model loading (with configurable language and speed), and text-to-speech inference that writes output as 16-bit PCM WAV files. The server listens on a configurable address (default localhost:50051) and supports optional Bearer token authentication via the LOCALAI\_GRPC\_AUTH\_TOKEN environment variable, intercepting requests to validate the authorization header before processing.

backend/rust/kokoros · high confidence

Introduce LocalAI desktop launcher with auto-start, secure downloads, and scoped paths

This change adds the LocalAI desktop launcher (cmd/launcher/internal), a Fyne-based application that manages the LocalAI server lifecycle. The launcher automatically starts the server on launch to ensure the service is available immediately, and scopes generated-content and upload directories to the user's data folder to prevent permission errors on shared systems. It includes a robust release manager that bypasses GitHub API rate limits by using release redirects, supports resumable downloads with rate limiting, and enforces security by refusing HTTP redirects on outbound clients. The UI provides configuration for models/backends paths, environment variables, and logging, along with system tray integration for start/stop controls and update notifications.

cmd/launcher/internal · high confidence

Introduce LocalAI desktop launcher with system tray and welcome screen

The cmd/launcher directory now contains a new Fyne-based desktop application for LocalAI. This launcher provides a native UI that minimizes to a system tray icon instead of closing, handles graceful shutdown via signal handling, and displays a welcome window when the configuration option is enabled. The application is configured with the LocalAI branding, including a specific app ID (com.localai.launcher) and icon.

cmd/launcher · high confidence

Introduce LocalVQE backend for acoustic echo cancellation

Adds a new LocalVQE backend to the audio processing pipeline, enabling acoustic echo cancellation and noise gate features. This change introduces the Go-based gRPC server (golocalvqe.go, main.go) that binds to the upstream LocalVQE C++ library via purego, along with build infrastructure (Makefile, package.sh, run.sh) to compile and bundle the required shared libraries (liblocalvqe.so, libggml-\*.so) for Linux and macOS. The backend supports configuration via model options for noise gate thresholds and backend selection, and includes a test suite (localvqe\_test.go) to verify WAV parsing and option handling.

backend/go/localvqe · high confidence

Introduce MLX backend with thread-safe prompt caching

Adds a new MLX inference backend to the Python backend suite, enabling users to run models using Apple's MLX framework. This backend includes a thread-safe LRU prompt cache to improve performance by reusing KV cache states across concurrent requests, and supports standard sampling parameters including min\_p and top\_k. The implementation provides gRPC service methods for health checks, model loading, and text prediction, along with integration tests to verify concurrent request safety and cache reuse.

backend/python/mlx · high confidence

Introduce Open Responses API with WebSocket support, distributed store, and MCP integration

Adds a new /v1/responses endpoint implementing the Open Responses specification, including a WebSocket transport for streaming events. The implementation introduces a response store with configurable TTL, bounded resume buffers (8192 events / 64 MiB), and cross-replica synchronization via NATS to make responses visible and cancellable across distributed replicas. It also supports MCP tool injection from metadata, handles previous\_response\_id chaining for conversation history, and fixes message conversion to populate both Content and StringContent fields.

core/http/endpoints/openresponses · high confidence

Introduce P2P network explorer with local token database

The core/explorer package now includes a local JSON-based database (database.go) for persisting P2P network tokens along with their name, description, and cluster metadata, protected by file locking for safe concurrent access. This storage layer supports the new DiscoveryServer (discovery.go), which automatically discovers and syncs installed models across instances by connecting to P2P networks, tracking cluster workers, and removing tokens that exceed a configurable failure threshold. Comprehensive tests (database\_test.go, explorer\_suite\_test.go) verify the database's add, retrieve, delete, and persistence capabilities.

core/explorer · high confidence

Introduce Python backend template with standardized build and runtime scripts

A new common template for Python-based backends has been added, providing a standardized set of shell scripts (install.sh, run.sh, test.sh, protogen.sh) and a Makefile to handle backend lifecycle operations. This template sources shared utilities from the common library to manage dependency installation (including specific workarounds for Intel pip index issues), gRPC code generation, backend startup, and unit testing, ensuring consistent behavior across different Python backend implementations.

backend/python/common/template · high confidence

Introduce Qwen-TTS backend for text-to-speech generation

Adds a new gRPC-based backend for the Qwen3-TTS model, enabling text-to-speech synthesis. The implementation includes a Python service (backend.py) that handles model loading, device detection (CUDA/MPS/CPU), and voice configuration via options. It also provides supporting scripts for installation (install.sh), running (run.sh), and testing (test.sh, test.py) to ensure the service operates correctly.

backend/python/qwen-tts · high confidence

Introduce TurboQuant llama.cpp fork backend

Adds a new TurboQuant backend (a llama.cpp fork) alongside the existing standard llama.cpp backend. This includes build infrastructure (Makefile, patch scripts) to compile the fork with specific CPU variants (AVX2, AVX512, etc.) and a single-build CPU-all-variants target, as well as packaging and runtime scripts to bundle the binary and required GPU/CPU libraries.

backend/cpp/turboquant · high confidence

Introduce cloud-proxy backend for OpenAI and Anthropic integration

A new LocalAI backend binary, cloud-proxy, is added to forward model traffic to external HTTP providers. It supports two modes: passthrough, which preserves the client wire format end-to-end, and translate, which converts internal proto requests to the provider's wire format for OpenAI and Anthropic. The translate mode handles specific provider requirements, such as hoisting system messages, mapping tool calls, and injecting Anthropic prompt-cache breakpoints. The backend also enforces security by refusing HTTP redirects on outbound clients to prevent API key leakage.

backend/go/cloud-proxy · high confidence

Introduce distributed failover state synchronization via NATS

Added a new \distsync\ package that synchronizes failover state (pins, target health, and chain state) across frontend instances using NATS. The implementation uses durable, store-backed maps for pin records to ensure late-joining instances hydrate from the database and repair missed deltas, while ephemeral maps handle live target and chain snapshots. This enables consistent failover behavior across a cluster of frontends.

core/services/failover/distsync · high confidence

Introduce fish-speech TTS backend with platform-specific build fixes

Adds a new fish-speech backend for text-to-speech, including a gRPC server implementation, installation scripts, and integration tests. The backend includes specific fixes to ensure compatibility across platforms: it allows the \invalid\_reference\_casting\ lint to enable building on macOS (Darwin), preserves ROCm PyTorch dependencies instead of replacing them with CUDA wheels, patches PyTorch/torchaudio versions for CUDA 13 on ARM64, and sets the \TRITON\_PTXAS\_PATH\ to support CUDA toolkit usage. It also replaces \torchaudio\ with \soundfile\ for reference audio loading to support Linux ARM64 environments lacking \torchcodec\ wheels.

backend/python/fish-speech · high confidence

Introduce ik-llama-cpp gRPC backend with multimodal support

Adds a new C++ gRPC backend server for the ik\_llama.cpp fork, enabling users to run inference via the LocalAI gRPC protocol. The implementation includes build scripts (CMakeLists.txt, Makefile) and a packaging script to handle dependencies and GPU libraries, while the server code integrates the mtmd library to support multimodal inputs (images/audio) and applies patches to ensure compatibility with the upstream ik\_llama.cpp API.

backend/cpp/ik-llama-cpp · high confidence

Introduce local-store as an in-process vector search backend

A new local-store backend has been added, providing an in-process vector storage solution exposed via gRPC. This component implements a sorted parallel-slice store with binary-search lookups and linear-scan top-K retrieval, supporting Set, Get, Delete, and Find operations. It includes strict validation for key dimensions and namespace prefixes to prevent cross-contamination, and features an optimized fast path for normalized vectors. The package includes build scripts, a clean target, and a comprehensive test suite covering edge cases like dimension mismatches and partial deletions.

backend/go/local-store · high confidence

Introduce native C++ audio backend with gRPC server

Adds a new native C++ audio backend (\audio-cpp\) that exposes a gRPC server for audio processing tasks. This new component includes a build system (CMake/Makefile) to compile against the \audio.cpp\ engine, handling audio I/O, format conversions, and capability routing. It supports multiple hardware backends including CUDA, ROCm, Vulkan, and Metal, and provides specific implementations for tasks like VAD, ASR, and source separation.

backend/cpp/audio-cpp · high confidence

Introduce rerankers gRPC backend with top\_n support

Adds a new Python-based gRPC backend for reranking models, including the server implementation, installation/run scripts, and unit tests. The backend exposes Health, LoadModel, and Rerank services, allowing users to load reranker models and retrieve ranked document lists. It supports the top\_n parameter to limit the number of returned results, and correctly handles cases where top\_n is omitted or set to zero by returning all ranked documents.

backend/python/rerankers · high confidence

Introduce sglang as a new gRPC backend

Adds a new Python-based gRPC backend for sglang, mirroring the existing vLLM backend structure. The implementation includes a \backend.py\ servicer that wraps sglang's async Engine API, supporting engine argument validation against \ServerArgs\ (handling both dataclass and msgspec-based configurations in sglang \>= 0.5.20), tool call parsing, and reasoning content extraction. It also provides build, run, and test scripts (\install.sh\, \run.sh\, \test.sh\) to handle dependencies, environment setup (including CPU-specific libraries like libiomp5), and unit testing for the backend's helper functions.

backend/python/sglang · high confidence

Introduce stablediffusion-ggml backend with VAE tiling and video generation support

The stablediffusion-ggml backend is now available as a standalone Go-based component, replacing the previous integrated approach. This backend leverages the leejet/stable-diffusion.cpp library (updated to version c92d73c) and exposes new capabilities including video generation (GenVideo) and configurable VAE tiling (allowing users to set tile sizes and overlap to manage memory usage). The build system supports multiple CPU instruction set variants (AVX, AVX2, AVX512) and GPU backends (CUDA, ROCm, Metal, Vulkan, SYCL), with automatic runtime selection of the appropriate library variant based on the host CPU. The backend is packaged with its own run script and library dependencies, ensuring it can operate independently.

backend/go/stablediffusion-ggml · high confidence

Introduce standalone Go-based Whisper backend with streaming and VAD

The whisper backend is now a separate Go service (backend/go/whisper) that wraps whisper.cpp via purego instead of cgo. This new backend adds streaming transcription (emitting segment deltas progressively), voice activity detection (VAD), and client-request cancellation support. It also ships multiple CPU-optimized shared libraries (AVX, AVX2, AVX512, and a fallback) on Linux, with Darwin using a single fallback variant. The service listens on a configurable address (honoring both the -addr flag and a positional argument) and includes tests for cancellation and streaming behavior.

backend/go/whisper · high confidence

Introduce standalone Piper TTS backend

Adds a new, standalone Piper text-to-speech backend that can be built and packaged independently from the main LocalAI binary. This change introduces a dedicated Go implementation (main.go, piper.go) that exposes a gRPC service for TTS operations, along with a Makefile to manage the go-piper dependency and espeak-ng data, and packaging scripts to bundle the binary with its required shared libraries for runtime execution.

backend/go/piper · high confidence

Introduce swappable face-recognition registry with replay-safe enrollment

The face-recognition service now uses a new Registry interface backed by LocalAI's in-memory gRPC vector store, enabling 1:N identification, embedding registration, and deletion. The implementation derives enrollment IDs deterministically from the embedding vector, so re-registering the same face (or replaying saved enrollments after a restart) preserves the original identity instead of creating duplicates. The registry is designed to be swappable; a persistent PostgreSQL/pgvector backend is planned for production use, but the current in-memory store loses data on restart.

core/services/facerecognition · high confidence

Introduce vLLM Python backend with multi-platform support and testing

This change adds the vLLM Python backend to the system, providing a new inference path that supports CPU, CUDA, ROCm, Intel XPU, and Apple Silicon (Metal/MLX) hardware profiles. The backend includes a gRPC servicer (backend.py) that handles model loading, text generation, and tool-call parsing, along with installation scripts (install.sh) that manage environment setup and dependency resolution for each platform. A packaging script (package.sh) bundles necessary system libraries and a C++ toolchain for CPU profiles to ensure portability. The entry also includes a comprehensive test suite (test.py) verifying gRPC service startup, model loading, sampling parameters, and message parsing, alongside standard build/run/test Makefile targets.

backend/python/vllm · high confidence

Introduce voice recognition service with multi-encoder support

This change introduces a new \voicerecognition\ service that manages speaker embeddings and performs 1:N identification. The service supports multiple speaker encoder dimensions by maintaining separate vector stores per dimension (e.g., 192 vs 256), ensuring that identification queries only match against voices of the same dimension. It also introduces a selection mechanism (\SelectKnownVoices\) that filters registered voices based on the active speaker model's encoder, supporting both file-name-based matching and explicit encoder family/weights fingerprints for portable enrollment. The service includes a registry interface for registering, identifying, forgetting, and listing voices, backed by a generic store resolver.

core/services/voicerecognition · high confidence

Introduces a reflection-based model configuration metadata system for the UI editor

A new \core/config/meta\ package automatically generates structured metadata for the \ModelConfig\ struct by walking its fields via reflection, inferring UI types (e.g., int, bool, string-list), and grouping them into ordered sections (General, LLM, Parameters, etc.). This metadata is enriched by a registry of overrides that provide human-readable labels, descriptions, specific UI components (like \select\ or \code-editor\), and constraints (min/max/step). The system supports dynamic autocomplete providers for fields like backends and models, and static option lists for things like quantization and pipeline types. This change provides the foundational data structure that powers the interactive model configuration editor with autocomplete and proper field validation. Also in this area: New PII detection configuration options for word extension and protected terms; Opt-in profiling and request timing diagnostics with improved upscale error handling; Native decision routing and VAD transcription ordering fixes.

core/config/meta · high confidence

Introduces advisory lock service with PostgreSQL and SQLite support

Adds a new advisory lock service in core/services/advisorylock that provides distributed coordination for PostgreSQL (using pg\_try\_advisory\_lock and pg\_advisory\_lock) and a fallback in-process mutex for SQLite. The service includes a HeldLock type for sticky leader election that manages a dedicated database session with short TCP keepalives to detect dead hosts, and a RunLeaderLoop helper for periodic tasks. It also bounds lock acquisition times to prevent hangs from hung databases or short server-side lock\_timeouts, and defines global lock keys for features like cron scheduling, failover probing, and schema migration.

core/services/advisorylock · high confidence

Introduces prefix-cache-aware routing for distributed mode

Adds a new prefix-cache routing subsystem that extracts a deterministic hash chain from the prompt head and tracks which replica served which prefix in an in-memory radix tree. The system provides a pluggable routing pipeline with configurable filters, weighted scorers, and pickers, allowing requests to be routed to the replica holding the longest matching prefix (hot match) while falling back to load-balanced cold placement when no match exists or the matched replica is unavailable. It includes configuration for thresholds, TTLs, and scorer weights, a pressure-tracking mechanism to signal cache saturation for autoscaling, and a reported-index provider that can be populated by backend residency events instead of request observations.

core/services/nodes/prefixcache · high confidence

Model configuration administration service with distributed revision consistency

A new \modeladmin\ service has been introduced to manage the configuration of installed models, providing a unified API for reading, patching, and mutating model YAML files (including enable/disable and pin/unpin actions) while ensuring data integrity through atomic file writes and mutation rollbacks. To support distributed deployments, the service implements a revision lifecycle that publishes authoritative configuration hashes to the node registry, allowing replicas to reconcile state via cache-invalidation events and automatically resync stored revisions at startup to prevent models from becoming unroutable due to revision drift.

core/services/modeladmin · high confidence

NATS messaging layer adds distributed install progress, cancellation, and security features

The core messaging service now supports distributed deployments with a new BackendInstallProgressEvent that publishes worker install phases (resolving, downloading, extracting, starting) to NATS, allowing the UI to show real-time progress. It introduces a CancelRegistry for managing cancellable operations and new NATS subjects for cancelling in-flight responses and backend upgrades. Security is enhanced with support for NATS JWT authentication (including dynamic providers) and TLS/mTLS configuration. The messaging client also validates subscription permissions synchronously to prevent silent failures and sanitizes NATS subject tokens to handle reserved characters safely.

core/services/messaging · high confidence

New C++ bindings for Stable Diffusion generation

The backend now includes a new C++ interface (gosd.cpp/gosd.h) that exposes Stable Diffusion image and video generation capabilities to the Go layer. This addition introduces functions for creating and configuring image generation parameters (prompts, dimensions, seed), loading models, and generating images, as well as video generation parameters and generation functions. It also implements embedding and LoRA discovery from directories and parsing of LoRA tags from prompts. Also in this area: MiniMax-H3 video generation with reference conditioning support; ESRGAN upscaling and custom noise schedules for Stable Diffusion GGML.

backend/go/stablediffusion-ggml/cpp · high confidence

New C++ privacy-filter backend for PII/NER detection

A new standalone C++ gRPC backend has been added to handle Personally Identifiable Information (PII) and Named Entity Recognition (NER) filtering. This backend wraps the privacy-filter.cpp GGML engine, replacing the previous llama.cpp-patched path for this specific model family. It supports CPU, CUDA, and Vulkan execution, manages model loading and token classification via gRPC, and includes logic to reject requests routed to the wrong model identity in distributed deployments.

backend/cpp/privacy-filter · high confidence

New C++/ggml backend for Depth Anything 3 depth estimation

Adds a new C++/ggml-based backend for Depth Anything 3, enabling users to run depth estimation and camera pose inference locally via a gRPC service. The backend supports multiple CPU instruction set variants (AVX, AVX2, AVX512, fallback) and includes a nested metric model mode for higher-precision depth maps. It exposes two primary capabilities: generating min-max-normalized grayscale depth images and predicting depth statistics with camera extrinsics/intrinsics. The implementation uses purego to dynamically load the C++ shared library and handles model loading via a two-file pair (anyview + metric) when specified.

backend/go/depth-anything-cpp · high confidence

New CLI commands for standalone agents, distributed workers, backend management, and benchmarking

The CLI now includes several new commands to manage and operate LocalAI components outside the main server process. Users can run standalone agents via \localai agent run\ (loading configuration from a JSON file or the agent pool registry) and list registered agents with \localai agent list\. A new \localai agent-worker\ command allows nodes to register with the frontend, authenticate via NATS JWT/mTLS, and execute agent jobs in distributed mode. Backend management is now accessible through \localai backends\ (list, install, uninstall, upgrade), supporting gallery-based installations and integrity checks. Additionally, a \localai benchmark\ command enables users to measure text inference performance (latency, throughput) against a running LocalAI server, with output available in table or JSON format.

core/cli · high confidence

New Face Recognition add-on with analysis and embedding tools

A new Face Recognition add-on is now available, providing a dedicated page to identify individuals in photos, verify if two images show the same person, and enroll known faces. The add-on includes advanced developer tools for detecting faces, guessing attributes (age, gender, emotion, race), and extracting raw face embeddings. It requires a face-recognition model to be installed on the server and respects user permissions, displaying a clear notice if the feature is disabled for the account.

(repo-wide) · high confidence

New Go-based face-detect backend replaces Python implementation

A new Go backend for face detection and verification has been added to replace the previous Python-based insightface implementation. This change introduces a self-contained gRPC service that loads the upstream face-detect.cpp library via purego, providing face detection, embedding generation, and biometric verification capabilities. The backend supports various hardware acceleration backends (CPU, CUDA, ROCm, Vulkan, Metal) and includes a build system to compile the C++ library and package it with necessary runtime dependencies.

backend/go/face-detect · high confidence

New HTTP middleware layer for routing, compression, and security

This change introduces a comprehensive set of new HTTP middleware components in the core request pipeline. It adds an admission control middleware that enforces per-model concurrency limits and returns HTTP 503 with a Retry-After header when capacity is reached. A new compression middleware enables gzip responses for static assets and JSON APIs while explicitly excluding streaming endpoints (SSE, WebSockets) to prevent latency issues. The pipeline now includes robust base URL and path prefix handling that correctly resolves reverse-proxy configurations (including Caddy's path stripping) while validating the X-Forwarded-Prefix header to prevent open-redirect vulnerabilities. Additionally, a new node header middleware stamps the X-LocalAI-Node response header with the ID of the distributed worker that served the request, using a per-request holder to ensure correct attribution in concurrent multi-replica scenarios. Context compression middleware is also added to transform chat requests before they reach the backend. Also in this area: 17 commits (7 fixes) modifying core; Model imports with remote assets are now queued for background processing; Faster model resolution for explicitly named requests; Opt-in profiling and request timing diagnostics with improved upscale error handling; Native decision routing and VAD transcription ordering fixes.

core/http/middleware · medium confidence · unverified

New HTTP route registration files for agents, Anthropic, auth, and distributed cluster capabilities

The \core/http/routes\ package now includes dedicated registration files for several new and refactored capabilities. \agents.go\ registers the full agent pool API (CRUD, chat, skills, collections) behind a readiness middleware. \anthropic.go\ implements the Anthropic Messages API compatibility layer with request context and PII filtering. \auth.go\ and its tests introduce a comprehensive authentication system with local/OIDC/GitHub providers, session management, and strict field-tampering protection on user profiles. \cluster\_capabilities.go\ and \cluster\_memory.go\ provide distributed-mode logic for backend discovery and model sizing, allowing controllers to query worker node capabilities and memory budgets instead of relying solely on local hardware. Also in this area: 17 commits (7 fixes) modifying core; Model imports with remote assets are now queued for background processing; Opt-in profiling and request timing diagnostics with improved upscale error handling; Native decision routing and VAD transcription ordering fixes; Agent worker messaging is abstracted behind interfaces.

core/http/routes · medium confidence · unverified

New LocalAI proxy backend for remote API bridging

A new \localai-proxy\ backend has been added to serve as a bridge between the local gRPC interface and a remote LocalAI instance's REST API. This allows users to offload model inference to a remote server while maintaining the local backend contract. The proxy supports a wide range of modalities, including text, audio (TTS, transcription, sound generation), images, video, and 3D generation. It also introduces support for live, real-time transcription sessions via WebSocket. The implementation includes robust handling of streaming responses, secure URL validation for generated content, and proper error mapping to ensure compatibility with local failover mechanisms.

backend/go/localai-proxy · high confidence

New MLX Distributed Inference Backend

Adds a new MLX distributed inference backend for LocalAI, enabling multi-GPU inference via pipeline parallelism. The backend supports two distributed modes—Ring (using MLX hostfiles) and Jaccl (using RDMA devices)—and includes a coordinator to broadcast commands and tokens across ranks. It also features a thread-safe LRU prompt cache for single-node efficiency and auto-parallel sharding of model layers across available devices.

backend/python/mlx-distributed · high confidence

New Opus audio codec backend for WebRTC

A new Opus audio codec backend has been added to the Go backend directory, enabling audio encoding and decoding for the WebRTC feature. This backend implements a gRPC service that wraps the libopus library (via a C shim and purego) to handle PCM-to-Opus encoding and Opus-to-PCM decoding. It includes logic to refuse loading foreign models, ensuring it is only used for its specific audio codec role, and supports session-based decoder caching for stateful decoding. The package includes build scripts and packaging logic to bundle the necessary shared libraries for both Linux and macOS.

backend/go/opus · high confidence

New Qwen3-TTS C++ backend with voice cloning and streaming

A new text-to-speech backend is available for Qwen3-TTS GGUF models, powered by the qwentts.cpp library. This backend supports 24 kHz speech generation, streaming audio output, named speakers, voice design, and reference-audio voice cloning. It includes a Go wrapper and C++ bridge, with build scripts that fetch the upstream library (held at commit 35ebe537 to avoid a synthesis hang) and compile CPU variants (AVX, AVX2, AVX512, fallback) and GPU backends (CUDA, HIP, Metal, Vulkan, SYCL). Users can install models like qwen3-tts-cpp and configure voice cloning via the tts.audio\_path setting or per-request voice references.

backend/go/qwen3-tts-cpp · high confidence

New Sherpa-ONNX backend for speech recognition, voice activity detection, and text-to-speech

A new Sherpa-ONNX backend has been added to the system, providing a unified Go-based implementation for offline and online speech recognition (ASR), voice activity detection (VAD), and text-to-speech (TTS). This backend supports multiple model families, including Whisper, Paraformer, SenseVoice, and Omnilingual for transcription, Silero for VAD, and VITS, Piper, and Kokoro for TTS. It also includes offline speaker diarization capabilities. The implementation uses purego bindings to interface with the Sherpa-ONNX C API, allowing for efficient execution without cgo overhead, and is packaged with the necessary shared libraries for deployment.

backend/go/sherpa-onnx · high confidence

New SyncedMap component for cross-replica state consistency

A new \SyncedMap\ component has been added to \core/services/syncstate\ to manage in-memory state across distributed replicas. It ensures consistency by broadcasting local changes (Set/Delete) via NATS to peers and optionally persisting to a durable Store. This prevents stale data when requests are load-balanced to different replicas, specifically supporting features like finetune, quant, and agent-tasks that previously relied on process-local state.

core/services/syncstate · high confidence

New WebUI static assets and chat functionality

The WebUI now includes a new set of static assets to support a redesigned interface and enhanced chat capabilities. This adds a comprehensive CSS animation system (\animations.css\) for UI transitions, a component style library (\components.css\) defining buttons, cards, and inputs, and a new SVG favicon. Additionally, a new \chat.js\ file implements the client-side logic for the chat interface, including features for managing chat history, auto-saving conversations to local storage, and handling streaming responses. Also in this area: 32 commits (10 fixes) modifying core/http.

core/http/static · medium confidence · unverified

New agent management and collection endpoints with per-user isolation

This change introduces a new set of HTTP endpoints for managing AI agents, agent jobs, skills, and vector collections, all located in the \core/http/endpoints/localai\ package. The implementation adds handlers for creating, listing, updating, and deleting agents (\agents.go\), managing agent tasks and job executions (\agent\_jobs.go\), handling skill definitions (\agent\_skills.go\), and performing CRUD operations on vector collections including uploads and searches (\agent\_collections.go\). A key behavioral addition is the \AgentResponsesInterceptor\ (\agent\_responses.go\), which routes \/v1/responses\ requests to local or distributed agents based on the model name. The endpoints enforce strict per-user data isolation, allowing admins and specific service accounts to impersonate users or aggregate data across all users via \?all\_users=true\ and \?user\_id=\ query parameters. The code also includes a fix for URL-decoding path parameters to handle legacy API key prefixes in collection names, and adds corresponding unit tests to verify the isolation and decoding logic. Also in this area: 17 commits (7 fixes) modifying core; Model imports with remote assets are now queued for background processing; Opt-in profiling and request timing diagnostics with improved upscale error handling; Speaker recognition now supports multiple encoder families and dimensions; Native decision routing and VAD transcription ordering fixes; and 1 more.

core/http/endpoints/localai · medium confidence · unverified

New backend and control-plane database monitoring metrics

The monitoring service now exposes new observability capabilities for backend stability and distributed cluster health. It introduces a BackendMonitorService that samples local backend process resource usage (CPU, memory) via gopsutil, providing a fallback when RPC status checks fail. Additionally, it registers OpenTelemetry gauges for the PostgreSQL control-plane database, tracking the oldest transaction snapshot age, the longest open transaction duration, and the dead-to-live tuple ratio on registry tables to help detect vacuum lag and database wedging before they cause outages.

core/services/monitoring · high confidence

New backends and capabilities: InsightFace antispoofing, MLX prompt caching, and TinyGrad tool parsing

This update introduces several new backend components. The InsightFace engine now supports antispoofing (liveness) detection using the Silent-Face MiniFASNet ensemble, allowing users to verify whether a detected face is real or a spoof. For MLX-based backends, a thread-safe LRU prompt cache has been added to improve performance by reusing cached KV states for similar prompts. Additionally, the experimental TinyGrad multimodal backend includes a new tool-call parsing system with support for Hermes-format tool calls, enabling better integration with models that output structured tool usage.

python · high confidence

New devcontainer lifecycle scripts and utility functions

The development container environment now includes dedicated lifecycle scripts and helper utilities to streamline setup and customization. A new \postcreate.sh\ script handles initial repository cloning or fetching and allows for custom post-creation logic via \/devcontainer-customization/postcreate.sh\. A \poststart.sh\ script ensures generated source files are present by running \make prepare\ on container start, also supporting custom pre-start logic. Additionally, \utils.sh\ provides helper functions for configuring git user/remote settings and securely setting up SSH keys from a customization directory, enhancing the flexibility and ease of use for developers working in the devcontainer.

.devcontainer-scripts · high confidence

New distributed storage layer with S3 support and local caching

The storage service now supports a distributed mode where files are stored in an S3-compatible object store (AWS S3 or MinIO) with a local cache on each node, while single-node mode continues to use the local filesystem. This change introduces a unified FileManager that handles uploads with progress tracking, downloads with singleflight deduplication to prevent thundering-herd issues, and automatic cleanup of ephemeral keys to prevent storage leaks. The implementation includes a new ObjectStore interface, S3 and Filesystem implementations, and comprehensive tests for upload, download caching, and deletion behaviors.

core/services/storage · high confidence

New distributed worker commands for vLLM, MLX, and DS4

The CLI now exposes dedicated subcommands to launch distributed inference workers: \vllm\ for vLLM data-parallel follower processes, \mlx-distributed\ for MLX distributed workers, and \ds4-distributed\ for DS4 layer-split workers. These commands handle backend discovery and installation from the gallery, accept extra arguments (e.g., \--llama-cpp-args\), and support node registration with labels (such as \vllm-follower\) for visibility in the admin UI. The vLLM follower specifically self-registers as an agent-type node to appear in the UI while scoping regular model placement away from it.

core/cli/worker · high confidence

New examples for MLX-Video, Silero VAD customization, and vLLM streaming benchmarks

This update adds several new example configurations and documentation to the examples directory. It introduces an MLX-Video example for Apple Silicon, including a model configuration for LTX-2.3 and instructions for video generation. It also provides a Silero VAD example demonstrating how to pass custom options like threshold and silence duration via model options. Additionally, a vLLM benchmarking tool is added to measure time-to-first-token for streaming responses with tool parsers, highlighting the performance difference between buffering and native streaming paths.

examples · high confidence

New llama.cpp-based quantization backend for GGUF model conversion

A new gRPC-based backend has been added to handle model quantization using the llama.cpp toolchain. This component allows users to download HuggingFace models, convert them to the GGUF format, and apply quantization (such as q4\_k\_m) to reduce model size. The backend manages the installation of necessary dependencies, including the \convert\_hf\_to\_gguf.py\ script and the \llama-quantize\ binary, and exposes a \StartQuantization\ API for initiating jobs with progress tracking. A corresponding test suite verifies the end-to-end workflow of downloading, converting, and quantizing a small model.

backend/python/llama-cpp-quantization · high confidence

New model importers for ACE-Step, Bark, Chatterbox, Coqui, Depth Anything, Diffusers, and DeepSeek V4

The gallery importer system now includes dedicated handlers for several new model types, allowing automatic detection and configuration for ACE-Step music generation, Suno's Bark TTS, Resemble AI's Chatterbox, Coqui TTS, ByteDance's Depth Anything 3 (via GGUF), Hugging Face Diffusers pipelines, and DeepSeek V4 Flash (ds4). These importers recognize models via Hugging Face repository metadata, URI patterns, or explicit backend preferences, and generate the necessary configuration files to route them to the correct inference backends.

core/gallery/importers · high confidence

New moss-transcribe-cpp backend for offline transcription and diarization

This change introduces the \moss-transcribe-cpp\ backend, enabling LocalAI to perform offline audio transcription, speaker diarization, and timestamping using the \moss-transcribe.cpp\ engine. The backend loads a GGUF model via a shared C library (\libmoss-transcribe.so\) and exposes a gRPC service that accepts audio files, normalizes them to 16 kHz mono WAV, and returns structured transcript segments with speaker labels and nanosecond-precision timestamps. It includes build automation via a Makefile to clone and compile the upstream C++ source at a pinned commit, packaging scripts to bundle the binary and required system/GPU libraries, and a Go-based test suite covering ABI validation, load validation, and transcript parsing logic.

backend/go/moss-transcribe-cpp · high confidence

New routing subsystem for concurrency control, usage billing, and KNN corpus management

This change introduces a new routing module in core/services/routing that adds per-model concurrency limiting (admission), usage tracking and billing (billing), and a managed corpus for KNN-based routing (corpus). The admission subsystem enforces per-model concurrency limits, returning HTTP 429 with a Retry-After header when limits are reached, and exposes in-flight/capacity metrics for dashboards. The billing subsystem provides a StatsBackend abstraction with three implementations: GORM-backed for authenticated deployments, an in-memory ring buffer for single-user/no-auth setups, and a disabled no-op for CI; it records token usage and costs, aggregates them for dashboards, and emits Prometheus counters for real-time monitoring. The corpus subsystem manages labeled exemplar data for KNN routing, persisting entries to JSONL files, handling embedding fingerprint mismatches, and re-seeding in-memory vector indexes when they become empty. These components work together to provide robust request routing, accurate usage accounting across different deployment modes, and reliable KNN-based model selection.

core/services/routing · high confidence

New shared Python backend infrastructure for authentication, model identity, and process safety

This change introduces a new \backend/python/common\ library that standardizes core behaviors across all LocalAI Python backends. It adds gRPC bearer token authentication (controlled by \LOCALAI\_GRPC\_AUTH\_TOKEN\), model-identity enforcement to prevent serving the wrong model in distributed setups, and a parent-death watcher to automatically terminate orphaned backend processes. It also provides shared utilities for parsing model references, handling chat templates and tool calls, and a bash library (\libbackend.sh\) for portable Python installation and backend lifecycle management.

backend/python/common · high confidence

New speaker-recognition backend for voice verification and analysis

A new Python-based gRPC backend has been added to handle speaker recognition, providing 1:1 voice verification, embedding extraction, and demographic analysis (age, gender, emotion). It supports two engine backends: a default SpeechBrain engine using the ECAPA-TDNN model for high-accuracy verification, and an OnnxDirect engine for CPU-friendly inference with pre-exported ONNX models. The service exposes endpoints for verifying speaker identity, extracting speaker embeddings, and analyzing voice demographics, with optional age/gender and emotion models that can be configured via gallery entries or environment variables.

backend/python/speaker-recognition · high confidence

New unified Transformers backend with multi-hardware and modality support

The \backend/python/transformers\ directory now contains a standalone, unified backend implementation that consolidates previous separate backends (such as SentenceTransformers and MusicGen) into a single service. This backend supports a wide range of Hugging Face model types, including causal language models, feature extraction, audio generation (MusicGen), and text-to-speech. It provides hardware acceleration for CUDA, Apple MPS, Intel XPU, and OpenVINO, and includes specific optimizations like 4-bit/8-bit quantization via BitsAndBytes and Intel extensions. The entry also introduces the necessary build infrastructure (Makefile, install/run scripts) and a comprehensive test suite covering model loading, embedding generation, and audio/TTS capabilities.

backend/python/transformers · high confidence

New vibevoice-cpp backend with streaming TTS and GPU support

This location introduces the build system, Go wrapper, and tests for the new vibevoice-cpp backend. It adds a CMake build configuration and Makefile that fetch and compile the vibevoice.cpp library, supporting CPU variants (AVX, AVX2, AVX512) and GPU backends (CUDA, ROCm/HIP, Metal, Vulkan). The Go code provides a purego binding to the C API, enabling both batch TTS and true streaming TTS (TTSStream) that delivers audio incrementally, along with ASR capabilities. The package includes integration and unit tests to validate the streaming callback framing and backend semantics.

backend/go/vibevoice-cpp · high confidence

New voice-detect backend replaces Python speaker-recognition with C++ engine

This location introduces the Go-based voice-detect backend, which replaces the previous Python speaker-recognition implementation. It loads the upstream voice-detect.cpp library (pinned to commit cf9e1d5641c710bf7d6fc9642f9b4cf7d2bde9b6) via purego to provide speaker embedding and verification capabilities. The backend now reports the encoder family and weights fingerprint for audio-registered voices, enabling more accurate voice matching. It supports various build types (CPU, CUDA, OpenBLAS, HIP, Vulkan, Metal) and includes packaging scripts to bundle necessary runtime libraries.

backend/go/voice-detect · high confidence

Ollama API compatibility layer for model inference and metadata

This change introduces a new Ollama-compatible HTTP API in the LocalAI server, enabling clients to interact with LocalAI using standard Ollama endpoints. The implementation includes handlers for chat (/api/chat), generation (/api/generate), and embeddings (/api/embed), which translate Ollama requests into the internal OpenAI-compatible format. It also adds model management endpoints (/api/tags, /api/show, /api/ps, /api/version, and root health check) that expose model metadata, including capabilities (e.g., embedding, completion, vision, tools, thinking), parameter size, and quantization level derived from model configurations. Additionally, the change includes logic to safely apply Ollama-specific options (like context size) with clamping to prevent integer overflow and denial-of-service risks, and supports the :latest tag for model lookups.

core/http/endpoints/ollama · high confidence

Parakeet.cpp backend adds dynamic batching, bundle GGUF support, and speaker diarization

The parakeet-cpp backend now supports dynamic batching of concurrent transcription requests to improve throughput, with requests coalesced by target language to match the underlying C-API constraints. It can load GGUF bundle files containing multiple model components (ASR, VAD, diarization, sound detection, speaker encoder), allowing users to enable features like speaker diarization, sound event detection, and speaker naming via specific model options. The backend also implements a voice verification threshold option and integrates with a shared voice registry to name speakers from diarization results.

backend/go/parakeet-cpp · high confidence

Placeholder directory for custom CA certificates

A new empty directory named custom-ca-certs has been added to the repository structure, containing only a .keep file to ensure the directory persists in version control. This establishes a location for future custom CA certificate configurations, though no actual certificate handling logic or user-facing functionality is implemented in this change.

custom-ca-certs · low confidence

Preload models from URIs at startup

Users can now specify model URIs (such as Hugging Face URLs or embedded YAML configurations) to be automatically downloaded and installed during application startup. The new \InstallModels\ function in the startup package handles resolving these URIs, downloading the necessary artifacts, and registering them with the model loader, ensuring models are available before the service becomes fully operational.

core/startup · high confidence

Scheduling rules can now be keyed by model aliases

Operators can now create node scheduling rules using an alias name (e.g., 'production') that maps to a physical model (e.g., 'qwen3'). The system resolves the alias to determine the actual target model for placement, allowing rules to persist even if the alias is repointed to a different model. The scheduler enforces that only one rule governs a single physical model to prevent conflicts, and the node registry now exposes the resolved target model alongside the operator-defined rule name.

core/services/nodes · high confidence

Worker registration client and NATS credential manager for distributed mode

Added a new worker registry package that provides a shared HTTP client for worker node registration, heartbeating, draining, and deregistration against the LocalAI frontend. This includes a NATS credential manager that handles acquiring credentials (waiting through admin approval if required) and automatically refreshing JWTs before they expire, ensuring long-running workers maintain valid authentication for NATS messaging.

core/cli/workerregistry · high confidence

Removals

Deprecation of legacy Alpine.js asset downloader

The tool previously used to download static assets for the legacy Alpine.js UI has been marked as deprecated. This component is no longer needed as the new React UI bundles all dependencies via npm, and the file will be removed once the legacy UI is fully retired.

_core/dependencies\manager · high confidence

Architecture

Refactored backend build system with dedicated Dockerfiles and pre-built CI base images

The backend build infrastructure has been restructured to decouple individual C++ and Go backends from the monolithic build process. New dedicated Dockerfiles (e.g., Dockerfile.audio-cpp, Dockerfile.llama-cpp, Dockerfile.bonsai) now define isolated build environments for specific backends, supporting multiple hardware targets including CPU, CUDA, ROCm, and Vulkan. A new \Dockerfile.base-grpc-builder\ establishes a standardized pre-built CI base image (\quay.io/go-skynet/ci-cache:base-grpc-\*\) containing shared dependencies like gRPC and CMake, which backend-specific Dockerfiles can leverage to ensure bit-equivalent builds between local development and CI. This change improves build isolation, caching efficiency via ccache, and maintainability by allowing each backend to specify its own dependencies and build scripts.

backend · high confidence

Behavioural changes

1 commit (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1 commit, 15 files: “feat(addons): installable add-ons foundation and the Tables add-on (\#12702)” (refs \#12702).

(repo-wide) · medium confidence · unverified

1 commit (0 fixes) modifying addons/sandbox/ui, core/services/addons/skilltree

A change to existing behaviour in addons/sandbox/ui, core/services/addons/skilltree — 1 commit, 14 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)” (refs \#12918).

addons/sandbox/ui, core/services/addons/skilltree · medium confidence · unverified

1 commit (0 fixes) modifying addons/ssh, addons/ssh/ui

A change to existing behaviour in addons/ssh, addons/ssh/ui — 1 commit, 48 files: “feat(addons): add the SSH add-on”.

addons/ssh, addons/ssh/ui · medium confidence · unverified

1 commit (0 fixes) modifying addons/testhost

A change to existing behaviour in addons/testhost — 1 commit, 1 file: “feat(studio): read and send large connector files by handle”.

addons/testhost · medium confidence · unverified

1 commit (0 fixes) modifying backend/go/timestral-cpp

A change to existing behaviour in backend/go/timestral-cpp — 1 commit, 17 files: “feat(backends): timestral.cpp forecast backend and /v1/forecast API (\#12885)” (refs \#12885).

backend/go/timestral-cpp · medium confidence · unverified

1 commit (0 fixes) modifying core/http/endpoints/client, core/http/tlsconf

A change to existing behaviour in core/http/endpoints/client, core/http/tlsconf — 1 commit, 7 files: “feat(addons): let paired clients call add-ons and use inference”.

core/http/endpoints/client, core/http/tlsconf · medium confidence · unverified

1 commit (0 fixes) modifying core/services/backendupdates, core/services/updatenotify

A change to existing behaviour in core/services/backendupdates, core/services/updatenotify — 1 commit, 8 files: “feat(ui): one place for backend and add-on updates, with inbox notifications (\#13154)” (refs \#13154).

core/services/backendupdates, core/services/updatenotify · medium confidence · unverified

10 commits (1 fix) modifying addons/github/internal

A change to existing behaviour in addons/github/internal — 10 commits (1 fix), 14 files: “refactor(addons): make manifest api 2 the only version”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): GitHub add-on skeleton and read tools”; and 7 more (refs \#13097).

addons/github/internal · medium confidence · unverified

10 commits (1 fix) modifying addons/slack/transport

A change to existing behaviour in addons/slack/transport — 10 commits (1 fix), 18 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “fix(connectors): leave one message per answer in a streamed reply”; “feat(slack): follow only the threads the bot started, and keep them”; and 7 more (refs \#12918).

addons/slack/transport · medium confidence · unverified

10 commits (2 fixes) modifying addons/github/ui/src

A change to existing behaviour in addons/github/ui/src — 10 commits (2 fixs), 7 files: “feat(github): show a real approval card for GitHub write proposals”; “feat(addons): GitHub settings page, registration and docs”; “fix(github): fit the write mode cards and the repository hint on one row”; and 7 more.

addons/github/ui/src · medium confidence · unverified

11 commits (1 fix) modifying core/services/addons/packages

A change to existing behaviour in core/services/addons/packages — 11 commits (1 fix), 12 files: “refactor(addons): make manifest api 2 the only version”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): add a feature level for new manifest fields”; and 8 more (refs \#12918, \#12943, \#13034, \#12881, \#12702, …).

core/services/addons/packages · medium confidence · unverified

11 commits (2 fixes) modifying core/services/localaitools/inproc

A change to existing behaviour in core/services/localaitools/inproc — 11 commits (2 fixs), 8 files: “feat(localaitools): add the client tools for inference”; “feat(localaitools): add the voice\_profile client tool”; “fix(branding): version asset URLs so logo changes show at once”; and 8 more (refs \#13154).

core/services/localaitools/inproc · medium confidence · unverified

120 commits (18 fixes) modifying core/http/endpoints/studio

A change to existing behaviour in core/http/endpoints/studio — 120 commits (18 fixs), 62 files: “fix(memory): grant the memory provider's skills to every chat that reads notes”; “fix(studio): tell the model and the owner when an add-on write tool is held back”; “feat(studio): add pageArea to home.json and an admin switch for it”; and 117 more (refs \#13129, \#13173, \#13097, \#13199, \#12918, …).

core/http/endpoints/studio · medium confidence · unverified

13 commits (3 fixes) modifying core/services/workerctl

A change to existing behaviour in core/services/workerctl — 13 commits (3 fixs), 11 files: “feat(chats): resume interrupted turns by themselves”; “fix(proxy): propagate model env and accept direct keys (\#12940)”; “feat(studio): let paired senders use the write tools of the agent's connected add-ons without a tick”; and 10 more (refs \#12940, \#12918, \#12754, \#12524, \#12395).

core/services/workerctl · medium confidence · unverified

14 commits (1 fix) modifying core/http/views

A change to existing behaviour in core/http/views — 14 commits (1 fix), 1 file: “chore(ux): add animated header with anime.js in p2p sections (\#3271)”; “feat(ui): left navbar, dark/light theme (\#8594)”; “chore(explorer): add join instructions (\#3255)”; and 11 more (refs \#3271, \#8594, \#3255, \#7397, \#5855, …).

core/http/views · medium confidence · unverified

16 commits (0 fixes) modifying backend/go/nemo-speech-cpp

A change to existing behaviour in backend/go/nemo-speech-cpp — 16 commits, 27 files: “chore: :arrow\_up: Update NVIDIA/NeMo-Speech.cpp to \56b60d432f1731d6d5b28a4c5a31cbaf871daba1\ (\#11846)”; “chore: :arrow\_up: Update NVIDIA/NeMo-Speech.cpp to \4f9676226f667d14608487df744f375db87127f8\ (\#11417)”; “chore: :arrow\_up: Update NVIDIA/NeMo-Speech.cpp to \e680fc30ac7404ba3acd58532f713becf8625894\ (\#12417)”; and 13 more (refs \#11846, \#11417, \#12417, \#13210, \#12982, …).

backend/go/nemo-speech-cpp · medium confidence · unverified

17 commits (2 fixes) modifying core/services/addons/hostops

A change to existing behaviour in core/services/addons/hostops — 17 commits (2 fixs), 37 files: “style(addons): gofmt the in-flight table of host operations”; “refactor(addons): pick engine job backends by gallery tag”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; and 14 more (refs \#12918, \#13034, \#12867, \#13009, \#12702).

core/services/addons/hostops · medium confidence · unverified

176 commits (48 fixes) modifying scripts

A change to existing behaviour in scripts — 176 commits (48 fixs), 82 files: “test(addons): inventory the resource listing specs”; “test(addons): match the updates and tables-tools inventories to a real run”; “test(addons): list the cases of sharing across frontends in the inventory”; and 173 more (refs \#7931, \#10098, \#10939, \#10951, \#12850, …).

scripts · medium confidence · unverified

A change to existing behaviour in gallery — 1917 commits (93 fixs), 113 files: “chore(model gallery): add nvidia\_openmath-nemotron-1.5b (\#5261)”; “chore(model gallery): add simplescaling\_s1.1-32b (\#4812)”; “chore(model-gallery): :arrow\_up: update checksum (\#12172)”; and 1899 more (refs \#5261, \#4812, \#12172, \#5121, \#6211, …).

gallery · medium confidence · unverified

2 commits (0 fixes) modifying addons/calendar

A change to existing behaviour in addons/calendar — 2 commits, 34 files: “feat(addons): add the Calendar add-on”; “feat(addons): give every add-on a real icon”.

addons/calendar · medium confidence · unverified

2 commits (0 fixes) modifying addons/tables/internal

A change to existing behaviour in addons/tables/internal — 2 commits, 29 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): installable add-ons foundation and the Tables add-on (\#12702)” (refs \#12918, \#12702).

addons/tables/internal · medium confidence · unverified

21 commits (4 fixes) modifying core/services/addons/runtime

A change to existing behaviour in core/services/addons/runtime — 21 commits (4 fixs), 16 files: “feat(addons): add an execution descriptor to the tool contract”; “test(addons): build the job lease test only on Linux”; “feat(addons): simplify Office and discover Tables (\#13029)”; and 18 more (refs \#13029, \#13097, \#12918, \#13034, \#13009, …).

core/services/addons/runtime · medium confidence · unverified

21 commits (6 fixes) modifying addons/sandbox/internal

A change to existing behaviour in addons/sandbox/internal — 21 commits (6 fixs), 149 files: “feat(sandbox): declare sandbox profiles in the add-on manifest”; “refactor(addons): make manifest api 2 the only version”; “fix(sandbox): check the fframes CLI by its real binary name”; and 18 more (refs \#13212, \#12918, \#13034, \#13033, \#13009).

addons/sandbox/internal · medium confidence · unverified

210 commits (37 fixes) modifying core/http/react-ui/public

A change to existing behaviour in core/http/react-ui/public — 210 commits (37 fixs), 235 files: “feat(images): add ESRGAN upscaling and Studio workflow (\#12620)”; “feat(ui): put Files in the chat header beside Dock”; “feat(realtime): Add Liquid Audio s2s model and assistant mode on talk page (\#9801)”; and 207 more (refs \#12620, \#9801, \#10030, \#11548, \#12785, …).

core/http/react-ui/public · medium confidence · unverified

22 commits (4 fixes) modifying core/services/addons/apps

A change to existing behaviour in core/services/addons/apps — 22 commits (4 fixs), 7 files: “refactor(addons): make manifest api 2 the only version”; “feat(addons): return the setup text from the kinds and add-ons APIs”; “refactor(addons): remove the shims for older add-on data”; and 19 more (refs \#13097, \#12918, \#13034, \#12702).

core/services/addons/apps · medium confidence · unverified

23 commits (1 fix) modifying core/services/addons/catalog

A change to existing behaviour in core/services/addons/catalog — 23 commits (1 fix), 21 files: “refactor(addons): remove the shims for older add-on data”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): GitHub settings page, registration and docs”; and 20 more (refs \#13097, \#12918, \#12898, \#13104, \#12702, …).

core/services/addons/catalog · medium confidence · unverified

23 commits (2 fixes) modifying addons/internal

A change to existing behaviour in addons/internal — 23 commits (2 fixs), 122 files: “feat(ui): one Connections item, and Gmail and Drive log in on their own pages”; “refactor(addons): make manifest api 2 the only version”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; and 20 more (refs \#13097, \#12918, \#13034, \#12702).

addons/internal · medium confidence · unverified

23 commits (3 fixes) modifying core/services/addons/policy

A change to existing behaviour in core/services/addons/policy — 23 commits (3 fixs), 40 files: “feat(home-assistant): take the address and login from the connection”; “refactor(addons): make manifest api 2 the only version”; “feat(addons): share resource kinds without the add-ons feature”; and 20 more (refs \#13097, \#12918, \#13167, \#12702).

core/services/addons/policy · medium confidence · unverified

254 commits (41 fixes) modifying core/schema

A change to existing behaviour in core/schema — 254 commits (41 fixs), 42 files: “fix: implement encoding\_format=base64 for embeddings endpoint (\#9135)”; “feat(images): add ESRGAN upscaling and Studio workflow (\#12620)”; “feat(llama.cpp): consolidate options and respect tokenizer template when enabled (\#7120)”; and 251 more (refs \#9135, \#12620, \#7120, \#9092, \#2649, …).

core/schema · medium confidence · unverified

268 commits (96 fixes) modifying core/application

A change to existing behaviour in core/application — 268 commits (96 fixs), 154 files: “fix(distributed): scale the remote model-load deadline with checkpoint size (\#11030)”; “feat(localaitools): add the client tools for inference”; “feat(localaitools): add the voice\_profile client tool”; and 265 more (refs \#11030, \#5971, \#10104, \#6059, \#8772, …).

core/application · medium confidence · unverified

272 commits (22 fixes) modifying swagger

A change to existing behaviour in swagger — 272 commits (22 fixs), 4 files: “feat(swagger): update swagger (\#8706)”; “feat(swagger): update swagger (\#6834)”; “fix(memory): grant the memory provider's skills to every chat that reads notes”; and 269 more (refs \#8706, \#6834, \#5253, \#11398, \#9356, …).

swagger · medium confidence · unverified

279 commits (100 fixes) modifying github.com/mudler/LocalAI

A change to existing behaviour in github.com/mudler/LocalAI — 279 commits (100 fixs), 79 files: “fix(failover): skip a target that has been edited into a chain”; “fix(chats): do not ask the tools hook twice for each message”; “feat(chats): resume interrupted turns by themselves”; and 276 more (refs \#12888, \#11163, \#6484, \#9270, \#13029, …).

github.com/mudler/LocalAI · medium confidence · unverified

3 commits (0 fixes) modifying addons/contacts

A change to existing behaviour in addons/contacts — 3 commits, 36 files: “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add the Contacts add-on”; “feat(addons): give every add-on a real icon” (refs \#13097).

addons/contacts · medium confidence · unverified

3 commits (0 fixes) modifying addons/fine-tuning/internal

A change to existing behaviour in addons/fine-tuning/internal — 3 commits, 6 files: “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): installable add-ons foundation and the Tables add-on (\#12702)” (refs \#13097, \#12918, \#12702).

addons/fine-tuning/internal · medium confidence · unverified

3 commits (0 fixes) modifying addons/gmail, addons/gmail/ui

A change to existing behaviour in addons/gmail, addons/gmail/ui — 3 commits, 47 files: “feat(ui): one Connections item, and Gmail and Drive log in on their own pages”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)” (refs \#13097, \#13167).

addons/gmail, addons/gmail/ui · medium confidence · unverified

3 commits (0 fixes) modifying addons/mail/ui

A change to existing behaviour in addons/mail/ui — 3 commits, 16 files: “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)”; “feat(addons): add the Mail add-on (IMAP and SMTP) (\#13104)”; “feat(connectors): show how many agents use a tool-only connection” (refs \#13167, \#13104).

addons/mail/ui · medium confidence · unverified

3 commits (0 fixes) modifying core/services/addons/backendlib

A change to existing behaviour in core/services/addons/backendlib — 3 commits, 5 files: “feat(addons): run the add-on owner as its own workload (\#12867)”; “feat(addons): list and install backends from a library (\#12816)”; “feat(addons): install development add-ons by tag, as backends do (\#12883)” (refs \#12867, \#12816, \#12883).

core/services/addons/backendlib · medium confidence · unverified

A change to existing behaviour in core/gallery/testdata — 3 commits (1 fix), 42 files: “feat(realtime): LFM3-Audio speech-to-speech on llama.cpp, remove liquid-audio (\#12958)”; “fix(gallery): drop the vllm.cpp MiniMax-H3 entries”; “feat(addons): list and install backends from a library (\#12816)” (refs \#12958, \#12816).

core/gallery/testdata · medium confidence · unverified

32 commits (3 fixes) modifying website

A change to existing behaviour in website — 32 commits (3 fixs), 81 files: “fix(website): rewrite the ecosystem band, drop two false coverage links”; “chore(website): refresh the counters (\#13028)”; “docs(blog): cover the terminal agent in the 4.8 post (\#11372)”; and 29 more (refs \#13028, \#11372, \#11582, \#11330, \#11697, …).

website · medium confidence · unverified

32 commits (7 fixes) modifying addons/internal/connector-ui/src/i18n

A change to existing behaviour in addons/internal/connector-ui/src/i18n — 32 commits (7 fixs), 10 files: “fix(studio): tell the model and the owner when an add-on write tool is held back”; “fix(connectors): link back to the agent, report what a save changes, keep non-ASCII file-change cards (\#13129)”; “feat(ui): one Connections item, and Gmail and Drive log in on their own pages”; and 29 more (refs \#13129, \#13097, \#13127).

addons/internal/connector-ui/src/i18n · medium confidence · unverified

339 commits (98 fixes) modifying core/http/react-ui/e2e

A change to existing behaviour in core/http/react-ui/e2e — 339 commits (98 fixs), 329 files: “feat(images): add ESRGAN upscaling and Studio workflow (\#12620)”; “feat(ui): put Files in the chat header beside Dock”; “fix(react-ui): polish 'Fits in my GPU' filter to use design-system Toggle (\#10030)”; and 336 more (refs \#12620, \#10030, \#11167, \#10104, \#12850, …).

core/http/react-ui/e2e · medium confidence · unverified

35 commits (3 fixes) modifying core/services/addons/tools

A change to existing behaviour in core/services/addons/tools — 35 commits (3 fixs), 24 files: “refactor(studio): decide command eligibility from the execution status”; “feat(studio): describe every built-in tool switch and let a saved agent set them”; “feat(addons): simplify Office and discover Tables (\#13029)”; and 32 more (refs \#13029, \#13097, \#12918, \#13034, \#13009, …).

core/services/addons/tools · medium confidence · unverified

36 commits (8 fixes) modifying core/http/endpoints/addons

A change to existing behaviour in core/http/endpoints/addons — 36 commits (8 fixs), 39 files: “fix(addons): run accepted upgrades on the owner (\#13035)”; “refactor(addons): make manifest api 2 the only version”; “feat(addons): share resource kinds without the add-ons feature”; and 33 more (refs \#13035, \#13097, \#12918, \#13034, \#12875, …).

core/http/endpoints/addons · medium confidence · unverified

37 commits (11 fixes) modifying core/services/addons

A change to existing behaviour in core/services/addons — 37 commits (11 fixs), 82 files: “fix(addons): copy credentials into declared capabilities”; “refactor(addons): share the upgrade conflict and wire checks”; “feat(addons): list installed add-ons and preview releases for host access”; and 34 more (refs \#13035, \#13097, \#12918, \#13038, \#13034, …).

core/services/addons · medium confidence · unverified

373 commits (104 fixes) modifying core/services/studio

A change to existing behaviour in core/services/studio — 373 commits (104 fixs), 964 files: “fix(mcpconns): guard the dial when private addresses are allowed”; “fix(chats): do not ask the tools hook twice for each message”; “feat(localaitools): add the voice\_profile client tool”; and 370 more (refs \#13129, \#13029, \#13173, \#13097, \#13212, …).

core/services/studio · medium confidence · unverified

39 commits (10 fixes) modifying core/services/localaitools

A change to existing behaviour in core/services/localaitools — 39 commits (10 fixs), 59 files: “feat(localaitools): add the client tools for inference”; “feat(localaitools): add the voice\_profile client tool”; “test: fix stale test names and restore the admin switch UI check”; and 36 more (refs \#13097, \#13154).

core/services/localaitools · medium confidence · unverified

4 commits (0 fixes) modifying addons/gdrive, addons/gdrive/ui

A change to existing behaviour in addons/gdrive, addons/gdrive/ui — 4 commits, 46 files: “feat(ui): one Connections item, and Gmail and Drive log in on their own pages”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)”; and 1 more (refs \#13097, \#13167).

addons/gdrive, addons/gdrive/ui · medium confidence · unverified

4 commits (0 fixes) modifying addons/home-assistant/ui

A change to existing behaviour in addons/home-assistant/ui — 4 commits, 18 files: “feat(connectors): use one vocabulary on the messaging connection page”; “feat(addons): add the Home Assistant add-on”; “feat(connectors): show how many agents use a tool-only connection”; and 1 more.

addons/home-assistant/ui · medium confidence · unverified

4 commits (0 fixes) modifying addons/jellyfin/ui

A change to existing behaviour in addons/jellyfin/ui — 4 commits, 16 files: “feat(connectors): use one vocabulary on the messaging connection page”; “feat(addons): add the Jellyfin add-on”; “feat(connectors): show how many agents use a tool-only connection”; and 1 more.

addons/jellyfin/ui · medium confidence · unverified

4 commits (0 fixes) modifying addons/quantization/internal

A change to existing behaviour in addons/quantization/internal — 4 commits, 6 files: “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “test(quantization): read the English title through Default()”; and 1 more (refs \#13097, \#12918, \#12702).

addons/quantization/internal · medium confidence · unverified

4 commits (0 fixes) modifying backend/go/kimodocpp

A change to existing behaviour in backend/go/kimodocpp — 4 commits, 13 files: “feat: Add kimodo.cpp and 3D animation API/UI (\#12095)”; “feat(kimodocpp): track usage through generic backend metadata (\#12162)”; “chore: :arrow\_up: Update localai-org/kimodo.cpp to \75ed52d2d3ec767a9bac79d11060b65d99f61a89\ (\#12973)”; and 1 more (refs \#12095, \#12162, \#12973, \#12780).

backend/go/kimodocpp · medium confidence · unverified

4 commits (0 fixes) modifying core/http/static/assets

A change to existing behaviour in core/http/static/assets — 4 commits, 26 files: “feat(ui): move model detailed info to a modal (\#4086)”; “chore: refactor css, restyle to be slightly minimalistic (\#7397)”; “feat(webui): statically embed js/css assets (\#2348)”; and 1 more (refs \#4086, \#7397, \#2348, \#2723).

core/http/static/assets · medium confidence · unverified

4 commits (1 fix) modifying addons/discord/transport

A change to existing behaviour in addons/discord/transport — 4 commits (1 fix), 13 files: “feat(addons): add the Discord connector add-on”; “fix(connectors): leave one message per answer in a streamed reply”; “feat(memory): add Always confirm, an agent save rule and a messaging row”; and 1 more.

addons/discord/transport · medium confidence · unverified

4 commits (1 fix) modifying addons/studio/ui

A change to existing behaviour in addons/studio/ui — 4 commits (1 fix), 53 files: “fix(addons): one page title, one primary action and clearer empty states (\#12850)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “docs: say who sees a voice profile and fix the messaging and assistant text”; and 1 more (refs \#12850, \#12918, \#12702).

addons/studio/ui · medium confidence · unverified

45 commits (12 fixes) modifying core/http/endpoints/mcp

A change to existing behaviour in core/http/endpoints/mcp — 45 commits (12 fixs), 17 files: “fix(mcp): connect to legacy SSE servers (\#12304)”; “feat(localaitools): add the client tools for inference”; “security(http): refuse redirects on outbound clients via hardened pkg/httpclient (\#10087)”; and 42 more (refs \#12304, \#10087, \#11316, \#6413, \#10360, …).

core/http/endpoints/mcp · medium confidence · unverified

451 commits (151 fixes) modifying core/http/react-ui

A change to existing behaviour in core/http/react-ui — 451 commits (151 fixs), 939 files: “feat(images): add ESRGAN upscaling and Studio workflow (\#12620)”; “feat(ui): put Files in the chat header beside Dock”; “feat(realtime): Add Liquid Audio s2s model and assistant mode on talk page (\#9801)”; and 448 more (refs \#12620, \#9801, \#10030, \#11167, \#10889, …).

core/http/react-ui · medium confidence · unverified

5 commits (0 fixes) modifying addons/mail

A change to existing behaviour in addons/mail — 5 commits, 37 files: “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)”; “feat(connectors): add the tool-only connector kind”; and 2 more (refs \#13097, \#13167, \#13104).

addons/mail · medium confidence · unverified

5 commits (0 fixes) modifying addons/pikvm/ui

A change to existing behaviour in addons/pikvm/ui — 5 commits, 20 files: “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)”; “feat(pikvm): let the owner skip the confirmation of power actions and keys”; “feat(pikvm): translate the PiKVM page into every language of the web UI”; and 2 more (refs \#13167).

addons/pikvm/ui · medium confidence · unverified

5 commits (0 fixes) modifying addons/studio, addons/talk

A change to existing behaviour in addons/studio, addons/talk — 5 commits, 21 files: “refactor(addons): make manifest api 2 the only version”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): declare typed host capabilities (\#13034)”; and 2 more (refs \#12918, \#13034, \#12702).

addons/studio, addons/talk · medium confidence · unverified

5 commits (0 fixes) modifying backend/go/strata

A change to existing behaviour in backend/go/strata — 5 commits, 35 files: “feat(strata): run DeepSeek V4.1-Flash and add its gallery entries (\#13132)”; “feat(strata): add an experimental backend for the Strata engine (\#13125)”; “feat(strata): add the GGUF models to the gallery and build the pack on first load (\#13131)”; and 2 more (refs \#13132, \#13125, \#13131, \#13138, \#13175).

backend/go/strata · medium confidence · unverified

5 commits (1 fix) modifying addons/github/ui

A change to existing behaviour in addons/github/ui — 5 commits (1 fix), 4 files: “feat(addons): GitHub settings page, registration and docs”; “feat(connectors): enforce add-on permissions on each connector turn”; “fix: restore the files that the previous commit removed by mistake”; and 2 more.

addons/github/ui · medium confidence · unverified

5 commits (1 fix) modifying addons/voice/ui

A change to existing behaviour in addons/voice/ui — 5 commits (1 fix), 33 files: “fix(addons): one page title, one primary action and clearer empty states (\#12850)”; “docs: say who sees a voice profile and fix the messaging and assistant text”; “feat(voiceprofile): let users own their voice profiles”; and 2 more (refs \#12850, \#12702).

addons/voice/ui · medium confidence · unverified

5 commits (2 fixes) modifying addons/talk/ui

A change to existing behaviour in addons/talk/ui — 5 commits (2 fixs), 17 files: “fix(addons): one page title, one primary action and clearer empty states (\#12850)”; “feat(realtime): LFM3-Audio speech-to-speech on llama.cpp, remove liquid-audio (\#12958)”; “fix(ui): keep focus in settings sheets when the page re-renders”; and 2 more (refs \#12850, \#12958, \#12702).

addons/talk/ui · medium confidence · unverified

50 commits (15 fixes) modifying core/services/addons/gateway

A change to existing behaviour in core/services/addons/gateway — 50 commits (15 fixs), 75 files: “feat(home-assistant): take the address and login from the connection”; “refactor(addons): share the upgrade conflict and wire checks”; “fix(addons): run accepted upgrades on the owner (\#13035)”; and 47 more (refs \#13035, \#13029, \#13097, \#12918, \#13034, …).

core/services/addons/gateway · medium confidence · unverified

54 commits (7 fixes) modifying backend/go/vllm-cpp

A change to existing behaviour in backend/go/vllm-cpp — 54 commits (7 fixs), 19 files: “chore: :arrow\_up: Update mudler/vllm.cpp to \c3bebc357385990f721af66a3a6c69328dd4fc6c\ (\#12252)”; “fix(vllm-cpp): build every CUDA architecture the platform can host (\#11512)”; “fix(vllm-cpp): mirror the engine's ABI v10 so the backend loads again (\#11386)”; and 51 more (refs \#12252, \#11512, \#11386, \#12734, \#12014, …).

backend/go/vllm-cpp · medium confidence · unverified

6 commits (0 fixes) modifying addons/face

A change to existing behaviour in addons/face — 6 commits, 10 files: “refactor(addons): make manifest api 2 the only version”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): declare typed host capabilities (\#13034)”; and 3 more (refs \#12918, \#13034, \#12702).

addons/face · medium confidence · unverified

6 commits (0 fixes) modifying addons/jellyfin

A change to existing behaviour in addons/jellyfin — 6 commits, 25 files: “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add the Jellyfin add-on”; “feat(addons): carry translated text in the manifest and the library”; and 3 more (refs \#13097).

addons/jellyfin · medium confidence · unverified

6 commits (0 fixes) modifying addons/sandbox/cmd

A change to existing behaviour in addons/sandbox/cmd — 6 commits, 7 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(sandbox): pull, cache and fall back for profile images”; “feat(sandbox): run background jobs in the Sandbox add-on”; and 3 more (refs \#12918, \#13009).

addons/sandbox/cmd · medium confidence · unverified

6 commits (0 fixes) modifying addons/web

A change to existing behaviour in addons/web — 6 commits, 23 files: “refactor(addons): make manifest api 2 the only version”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): declare typed host capabilities (\#13034)”; and 3 more (refs \#12918, \#13034).

addons/web · medium confidence · unverified

62 commits (12 fixes) modifying addons/internal/connector-ui/src

A change to existing behaviour in addons/internal/connector-ui/src — 62 commits (12 fixs), 33 files: “fix(studio): tell the model and the owner when an add-on write tool is held back”; “fix(connectors): link back to the agent, report what a save changes, keep non-ASCII file-change cards (\#13129)”; “feat(ui): one Connections item, and Gmail and Drive log in on their own pages”; and 59 more (refs \#13129, \#13097, \#12918, \#13167, \#13127).

addons/internal/connector-ui/src · medium confidence · unverified

7 commits (0 fixes) modifying addons/home-assistant

A change to existing behaviour in addons/home-assistant — 7 commits, 33 files: “feat(home-assistant): take the address and login from the connection”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add the Home Assistant add-on”; and 4 more (refs \#13097).

addons/home-assistant · medium confidence · unverified

7 commits (0 fixes) modifying addons/office

A change to existing behaviour in addons/office — 7 commits, 95 files: “feat(addons): simplify Office and discover Tables (\#13029)”; “refactor(addons): make manifest api 2 the only version”; “refactor(addons): remove the shims for older add-on data”; and 4 more (refs \#13029, \#12918, \#13034).

addons/office · medium confidence · unverified

7 commits (0 fixes) modifying core/services/addons/updates

A change to existing behaviour in core/services/addons/updates — 7 commits, 4 files: “refactor(addons): make manifest api 2 the only version”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(addons): add a feature level for new manifest fields”; and 4 more (refs \#12918, \#12702, \#12883).

core/services/addons/updates · medium confidence · unverified

7 commits (1 fix) modifying addons/fine-tuning/ui

A change to existing behaviour in addons/fine-tuning/ui — 7 commits (1 fix), 27 files: “fix(addons): one page title, one primary action and clearer empty states (\#12850)”; “feat(realtime): LFM3-Audio speech-to-speech on llama.cpp, remove liquid-audio (\#12958)”; “refactor(ui): remove the built-in copies of the add-on pages (\#12852)”; and 4 more (refs \#12850, \#12958, \#12852, \#12867, \#12702).

addons/fine-tuning/ui · medium confidence · unverified

7 commits (1 fix) modifying addons/quantization/ui

A change to existing behaviour in addons/quantization/ui — 7 commits (1 fix), 26 files: “fix(addons): one page title, one primary action and clearer empty states (\#12850)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “refactor(ui): remove the built-in copies of the add-on pages (\#12852)”; and 4 more (refs \#12850, \#12918, \#12852, \#12867, \#12702).

addons/quantization/ui · medium confidence · unverified

7 commits (1 fix) modifying addons/sandbox/images

A change to existing behaviour in addons/sandbox/images — 7 commits (1 fix), 18 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat(sandbox): own document authoring skills (\#13038)”; “feat(sandbox): ship matplotlib in the guest image”; and 4 more (refs \#12918, \#13038).

addons/sandbox/images · medium confidence · unverified

7 commits (1 fix) modifying core/services/finetune

A change to existing behaviour in core/services/finetune — 7 commits (1 fix), 6 files: “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat: add distributed mode (\#9124)”; “chore: Security hardening (\#9719)”; and 4 more (refs \#12918, \#9124, \#9719, \#10542, \#12702, …).

core/services/finetune · medium confidence · unverified

7 commits (1 fix) modifying core/services/testutil

A change to existing behaviour in core/services/testutil — 7 commits (1 fix), 7 files: “Revert "chore(tests): Avoid network, sleep and more during tests" (\#11601)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; “feat: add distributed mode (\#9124)”; and 4 more (refs \#11601, \#12918, \#9124, \#11050, \#10542, …).

core/services/testutil · medium confidence · unverified

7 commits (2 fixes) modifying core/services/addons/resources

A change to existing behaviour in core/services/addons/resources — 7 commits (2 fixs), 9 files: “feat(addons): share resource kinds without the add-ons feature”; “docs(sharing): say where the picker limit and the stop of chats hold”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; and 4 more (refs \#12918, \#12702).

core/services/addons/resources · medium confidence · unverified

7 commits (3 fixes) modifying core/services/addons/hostsettings

A change to existing behaviour in core/services/addons/hostsettings — 7 commits (3 fixs), 7 files: “feat(addons): add a host ceiling for connector files to the owner policy”; “fix(addons): check the private egress phrase on the owner”; “feat(sandbox): make media the default sandbox profile”; and 4 more (refs \#13033).

core/services/addons/hostsettings · medium confidence · unverified

77 commits (11 fixes) modifying core/http/auth

A change to existing behaviour in core/http/auth — 77 commits (11 fixs), 52 files: “fix(auth): protect HTTP routes by default (\#11602)”; “feat(chats): read the network a new chat would start with”; “security(http): refuse redirects on outbound clients via hardened pkg/httpclient (\#10087)”; and 74 more (refs \#11602, \#10087, \#11316, \#9101, \#9500, …).

core/http/auth · medium confidence · unverified

8 commits (0 fixes) modifying addons/discord/ui

A change to existing behaviour in addons/discord/ui — 8 commits, 18 files: “feat(connectors): let a channel trust its members for everyday actions”; “feat(addons): add the Discord connector add-on”; “feat(connectors): use one vocabulary on the messaging connection page”; and 5 more.

addons/discord/ui · medium confidence · unverified

8 commits (0 fixes) modifying addons/slack/ui

A change to existing behaviour in addons/slack/ui — 8 commits, 18 files: “feat(connectors): let a channel trust its members for everyday actions”; “feat(connectors): use one vocabulary on the messaging connection page”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; and 5 more (refs \#12918).

addons/slack/ui · medium confidence · unverified

8 commits (3 fixes) modifying core/services/addons/hostgrants

A change to existing behaviour in core/services/addons/hostgrants — 8 commits (3 fixs), 12 files: “feat(addons): make an operation added by an upgrade pending on its own”; “feat(addons): add the owner service and split forwarding for host access”; “fix(addons): keep grants made under a deployment blanket as the install's own”; and 5 more.

core/services/addons/hostgrants · medium confidence · unverified

8 commits (3 fixes) modifying core/services/voiceprofile

A change to existing behaviour in core/services/voiceprofile — 8 commits (3 fixs), 5 files: “test(voiceprofile): drop an unused assignment”; “\[voice\] feat: add managed voice cloning profiles (\#10799)”; “feat(voiceprofile): let users own their voice profiles”; and 5 more (refs \#10799).

core/services/voiceprofile · medium confidence · unverified

9 commits (0 fixes) modifying addons/pikvm

A change to existing behaviour in addons/pikvm — 9 commits, 32 files: “test(pikvm): drop the test of a removed approvals helper”; “feat(addons): generic OAuth 2.0 login for add-ons, with Google Drive and Gmail add-ons (\#13097)”; “feat(addons): add an Allow all write mode to mail, Gmail, Drive and PiKVM (\#13167)”; and 6 more (refs \#13097, \#13167).

addons/pikvm · medium confidence · unverified

9 commits (0 fixes) modifying addons/telegram/ui

A change to existing behaviour in addons/telegram/ui — 9 commits, 15 files: “feat(connectors): let a channel trust its members for everyday actions”; “feat(connector-ui): add a Files section to the connector page”; “feat(connectors): use one vocabulary on the messaging connection page”; and 6 more (refs \#12918).

addons/telegram/ui · medium confidence · unverified

9 commits (1 fix) modifying addons/telegram/transport

A change to existing behaviour in addons/telegram/transport — 9 commits (1 fix), 12 files: “feat(connectors): add /new to start a fresh chat from the app”; “feat(chats): let a connector binding limit the kinds of file it reads (\#13173)”; “feat(chats): server-side chats with steering, sub-agents and compaction (\#12918)”; and 6 more (refs \#13173, \#12918).

addons/telegram/transport · medium confidence · unverified

The gallery now enforces backend integrity by requiring SHA256 checksums or OCI signature verification (cosign) for installations, with strict mode blocking unverified backends. In distributed deployments, backend discovery and model sizing now correctly account for worker node capabilities and memory rather than being limited to the controller's hardware, ensuring GPU-only backends are visible and sized appropriately. Additionally, the gallery supports model variant collapsing to reduce listing clutter, provides detailed variant views (including memory footprint, quantization, and features) for auto-selection, and introduces backend versioning with metadata tracking for upgrades.

core/gallery · high confidence

HTTP server migration to Echo framework with enhanced security and performance

The HTTP server implementation has been migrated to the Echo framework, introducing several behavioral changes for users. Security is strengthened by defaulting to authentication for all HTTP routes, with a strict allowlist for public endpoints (health checks, login, static assets) and improved CSRF protection for multipart requests. Performance is improved through gzip response compression and immutable caching (one-year TTL) for content-hashed React UI assets. The server now handles model loading states more gracefully by returning 503 with Retry-After headers for both failed loads (cooldown) and in-progress loads, and respects the X-Forwarded-Prefix header for correct URL generation behind reverse proxies.

core/http · high confidence

Improved chat streaming reliability and spec compliance

The chat completion endpoint now correctly handles context overflow errors by returning a 400 Bad Request instead of a 500 error, allowing clients to adjust their context window. Streaming behavior has been fixed to comply with the OpenAI specification: usage data is no longer incorrectly included in intermediate chunks, and the final usage trailer is now properly emitted when requested. Additionally, reasoning content is now correctly separated from tool calls and text, preventing reasoning tags from leaking into the final response content.

core/http/endpoints/openai · high confidence

Introduce dynamic pipeline loader for automatic diffusers support

The diffusers backend now uses a dynamic loader that automatically discovers and loads any Hugging Face diffusers pipeline at runtime, eliminating the need for hardcoded per-pipeline conditionals. Users can now load new or custom pipelines (e.g., Flux, Wan, Sana) without code changes, resolving models by class name, task alias (like 'text-to-image'), or model ID. The backend also supports single-file model loading, optional prompt weighting via Compel and sd\_embed, and auto-detects CUDA availability instead of defaulting to CPU.

backend/python/diffusers · high confidence

Local AI CLI entry point restructured with enhanced logging and credential support

The local-ai command-line interface now initializes a new xlog-based logger that supports configurable log formats and optional log deduplication for terminal output. The startup process explicitly loads environment variables from multiple standard locations (including user-specific config paths) and introduces a credentials file mechanism to authenticate registries and downloads before running commands. Additionally, the CLI now passes its model definition to the completion command to enable dynamic shell completion script generation for bash, zsh, and fish.

cmd/local-ai · high confidence

New CLI context configuration for logging and credentials

The CLI now exposes a dedicated context struct that allows users to configure logging behavior and authentication sources. Users can set the log level (error, warn, info, debug, trace) and format (default, text, json) via environment variables or flags, and enable deduplication of consecutive identical log lines. Additionally, a credentials file path can be specified to authenticate against private registries, galleries, and download hosts.

core/cli/context · high confidence

New backend execution layer with distributed tracing and context propagation

The core/backend package has been refactored to introduce a new execution layer that standardizes model loading, slot acquisition, and distributed tracing across all inference types (LLM, image, audio, video, etc.). This change ensures that per-request context (including the X-LocalAI-Node header for distributed routing) is correctly propagated from the HTTP handler to the backend router, fixing previous issues where context was dropped. It also adds comprehensive backend tracing for observability, allowing users to track request durations, errors, and metadata for all backend operations.

core/backend · high confidence

New config package with runtime settings and backend capabilities

The core/config package has been restructured to introduce a single source of truth for default values and a new runtime settings system. This change adds a comprehensive backend capabilities registry that maps usecases (such as chat, vision, TTS, and video) to specific gRPC methods, ensuring accurate backend detection and routing. It also introduces VRAM-aware context sizing that automatically caps the default context window based on per-device memory to prevent load failures, and adds a configurable disk-headroom check for distributed mode. Additionally, the application configuration now supports runtime updates via a new ApplyRuntimeSettings mechanism, allowing operators to modify settings like watchdog behavior and concurrency without restarting the service.

core/config · high confidence

New llama.cpp gRPC backend with unified build and compatibility fixes

The llama.cpp backend is now built as a standalone gRPC server (grpc-server) with a dedicated CMakeLists.txt and Makefile, replacing the previous embedded build approach. This new build system introduces a single-build CPU variant (CPU\_ALL\_VARIANTS) that produces one binary with runtime-dynamic CPU backends, replacing the previous multi-binary AVX/AVX2/AVX512/fallback builds. The backend now includes robust compatibility handling for upstream llama.cpp refactors, automatically detecting the renamed llama-common library and conditionally including split source files (server-chat.cpp, server-schema.cpp, server-stream.cpp) to support both current and older fork versions. Additionally, it introduces message content normalization to prevent JSON-sniffing errors with plain-text prompts, adds gRPC bearer token authentication for distributed mode, and includes unit tests for message handling, stream peers, and model load errors.

backend/cpp/llama-cpp · high confidence

New template engine with caching, multimodal support, and structured data injection

The template system in core/templates has been rewritten to include a caching layer (cache.go) that loads and compiles templates once for reuse, improving performance. The new evaluator (evaluator.go) introduces structured data injection for prompts, allowing templates to access specific fields like SystemPrompt, ReasoningEffort, and Metadata, as well as detailed ChatMessage data including Role, FunctionCall, and ToolCalls. This enables more precise control over how function calls and tool responses are formatted in chat histories. Additionally, a new multimodal templating component (multimodal.go) handles the insertion of media markers for images, audio, and video, ensuring that multimodal content is correctly represented in the final prompt sent to the model. Tests confirm the new behavior for both standard chat and embedding scenarios.

core/templates · high confidence

New web UI design system and navigation structure

The web interface now uses a new design system built on Tailwind CSS and Alpine.js, replacing the previous styling and scripting approach. This change introduces a new sidebar navigation layout with sections for Home, Install Models, Chat, Images, Video, TTS, Sound, Talk, Agent Jobs, Traces, and System tools, along with a dedicated explorer navbar. Users benefit from a persistent dark/light theme toggle that respects system preferences and persists via local storage, as well as a global operations status bar that provides real-time progress updates and cancellation capabilities for background tasks like model imports or deletions. Also in this area: 32 commits (10 fixes) modifying core/http.

core/http/views/partials · medium confidence · unverified

Refactored Docker build system with shared scripts and configurable apt mirrors

The Docker build infrastructure has been restructured to use shared shell scripts (install-base-deps, apt-mirror, and specific compile/build-target scripts for llama-cpp, turboquant, bonsai, and ik-llama-cpp) instead of inline RUN blocks. This ensures bit-equivalence between local from-source builds and CI prebuilt images. A new apt-mirror script allows routing package downloads through alternate Ubuntu mirrors via environment variables to mitigate archive outages. Build logic now centralizes decisions on CPU variant compilation (e.g., using a single CPU\_ALL\_VARIANTS build or a fallback) based on architecture and backend type, fixing issues where GPU builds unnecessarily compiled CPU variants or where SYCL/ROCm builds exceeded time limits.

.docker · high confidence

TRL fine-tuning backend introduces GRPO inline reward security fix

The new TRL fine-tuning backend in backend/python/trl adds support for SFT, DPO, GRPO, and other training methods via a gRPC interface, including built-in reward functions and a Makefile/installation script. Crucially, inline reward code execution (GRPO) is disabled by default to prevent remote code execution; it now requires the LOCALAI\_TRL\_ALLOW\_INLINE\_REWARD environment variable to be explicitly set to a truthy value, with tests verifying this opt-in gate.

backend/python/trl · high confidence

macOS app notarization and offline verification support

The macOS distribution process now includes code signing and notarization for both the application bundle and the disk image. A new script (contrib/macos/sign-and-notarize.sh) and entitlements file handle the signing process, while the notarization step specifically staples the Apple notarization ticket to the .app bundle itself, not just the DMG. This ensures the application can verify its notarization status offline, preventing launch failures on machines without internet access or behind firewalls.

contrib · high confidence

Fixes

5 commits (3 fixes) fixing core/services/quantization

A fix in core/services/quantization — 5 commits (3 fixs), 5 files: “fix(quantization): record job progress without an attached listener (\#11874)”; “fix(quantization): pin the producing backend on imported quantized models (\#11875) (\#11879)”; “fix(quantization): claim the import under the lock that checks it”; and 2 more (refs \#11874, \#11875, \#11879, \#10542, \#12702).

core/services/quantization · medium confidence · unverified

This update resolves several issues in the gallery operation service that affected reliability and user experience. Operations that were cancelled or orphaned by a replica restart are now correctly persisted as terminal (cancelled or failed) in the gallery store, preventing them from resurrecting as active 'processing' tasks. The cancellable state of in-flight operations is now persisted, ensuring that users can still cancel downloads or installs after a service restart. Additionally, the service now correctly distinguishes between cancellable and non-cancellable phases (e.g., queued operations are cancellable, but running deletions are not), and ensures the deletion flag is carried forward through all status updates. Progress reporting for Hugging Face artifacts has been improved with a coalescer to reduce update frequency and ensure proportional progress during multi-file verification.

core/services/galleryop · high confidence

Test coverage

10 commits adding/updating tests in addons/github/ui/test; 169 commits adding/updating tests in core/http/react-ui/tests; 3 commits adding/updating tests in backend/go/stablediffusion-ggml/tests; 41 commits adding/updating tests in addons/telegram/ui/test; Added standalone C++ unit test runner script; Added test fixtures for internal addon build tooling; Added tests for distributed mode stores; New end-to-end test suites for AIO, backends, and UI; Worker test suite for address resolution, auth logic, and backend lifecycle.

Dependencies

Add dependency requirements for the Ace-Step music generation backend

Added Python dependency manifests (requirements files) for the new Ace-Step backend, covering CPU, CUDA 12/13, ROCm, Intel XPU, L4T13, and MPS hardware targets. These files define the necessary packages for the backend to function, including PyTorch variants, transformers, diffusers, and gradio.

(dependencies) · high confidence

Update ggerganov/llama.cpp

The ggerganov/llama.cpp submodule has been updated to the latest commit, bringing in upstream improvements and bug fixes.

(repo-wide) · high confidence

Housekeeping

Placeholder file added to configuration directory

A .keep file has been added to the configuration directory to ensure the directory is tracked by version control.

configuration · high confidence

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

How this codebase got here

Score

  • CAI 47 → 48 (+1.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 40 → 50 (+9.9)
  • Architecture 73 → 61 (-12.8)
  • Maturity 76 → 73 (-2.9)
  • Readiness 41 → 37 (-4.2)
  • Security 67 → 67 (-0.2)
  • Event-Driven 91 → 88 (-2.7)
  • Accessibility 51 → 57 (+6.4)
  • Performance 70 → 94 (+24.4)

Resolved (597)

  • (anonymous) (cognitive 90) (core/http/static/chat.js)
  • (anonymous) (cyclomatic 51) (core/http/static/chat.js)
  • (anonymous)::add (cognitive 27) (core/http/static/chat.js)
  • (anonymous)::add (cyclomatic 23) (core/http/static/chat.js)
  • (anonymous)::updateTokenUsage (cognitive 17) (core/http/static/chat.js)
  • (anonymous)::updateTokenUsage (cyclomatic 17) (core/http/static/chat.js)
  • ActivityFold.ActivityGroup (cognitive 16) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • ActivityFold.ActivityGroup (cyclomatic 22) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • AddonTile.AddonTile (cognitive 20) (core/http/react-ui/src/components/addons/AddonTile.jsx)
  • AddonTile.AddonTile (cyclomatic 21) (core/http/react-ui/src/components/addons/AddonTile.jsx)
  • AgentCreate.AgentCreate (cognitive 36) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.AgentCreate (cyclomatic 33) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.AgentCreate::foldInfo (cyclomatic 17) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.AgentCreate::renderSection (cognitive 16) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.AgentCreate::renderSection (cyclomatic 25) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.ConfigForm (cognitive 19) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.ConfigForm (cyclomatic 21) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.FormField (cognitive 20) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.FormField (cyclomatic 22) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • AgentCreate.PreviewSheet (cognitive 25) (core/http/react-ui/src/pages/AgentCreate.jsx)
  • …and 577 more

New (3565)

  • API.addressed (cognitive 18) (addons/telegram/transport/botapi.go)
  • API.doReader (cognitive 16) (addons/telegram/transport/botapi.go)
  • API.updates (cognitive 20) (addons/telegram/transport/botapi.go)
  • AccessMatrix.AccessMatrix (cognitive 64) (addons/internal/connector-ui/src/AccessMatrix.jsx)
  • AccessMatrix.AccessMatrix (cyclomatic 61) (addons/internal/connector-ui/src/AccessMatrix.jsx)
  • Account.Account (cognitive 29) (core/http/react-ui/src/pages/Account.jsx)
  • Account.Account (cyclomatic 30) (core/http/react-ui/src/pages/Account.jsx)
  • Account.Validate (cognitive 16) (addons/mail/internal/account/account.go)
  • Account.Validate (cyclomatic 18) (addons/mail/internal/account/account.go)
  • ActivityFold.AppRow (cognitive 16) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • ActivityFold.AppRow (cyclomatic 17) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • ActivityFold.useLiveTimes (cognitive 16) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • ActivityFold.useLiveTimes (cyclomatic 20) (core/http/react-ui/src/components/chat/ActivityFold.jsx)
  • AddonPreview.AddonPreview (cognitive 20) (core/http/react-ui/src/components/addons/AddonPreview.jsx)
  • AddonPreview.AddonPreview (cyclomatic 31) (core/http/react-ui/src/components/addons/AddonPreview.jsx)
  • AddonRow.AddonRow (cognitive 38) (core/http/react-ui/src/components/addons/AddonRow.jsx)
  • AddonRow.AddonRow (cyclomatic 45) (core/http/react-ui/src/components/addons/AddonRow.jsx)
  • AddonSkills.AddonSkills (cognitive 18) (core/http/react-ui/src/components/addons/AddonSkills.jsx)
  • AddonSkills.AddonSkills (cyclomatic 24) (core/http/react-ui/src/components/addons/AddonSkills.jsx)
  • AgentBits.FolderChip (cognitive 32) (core/http/react-ui/src/components/agents/AgentBits.jsx)
  • …and 3545 more

Changes since last survey

  • 300 commits — 205 feature/other, 95 fixes

By area

  • core/services — 103 commits
  • core/http — 93 commits
  • (repo) — 16 commits
  • backend/cpp — 16 commits
  • backend/go — 16 commits
  • addons/sandbox — 12 commits
  • docs/content — 7 commits
  • gallery/index.yaml — 5 commits
  • (root) — 4 commits
  • .github/workflows — 4 commits
  • scripts/addons — 4 commits
  • pkg/addons — 2 commits
  • swagger/docs.go — 2 commits
  • .agents/ci-caching.md — 1 commit
  • .agents/sandbox-profiles-and-media.md — 1 commit
  • addons/gdrive — 1 commit
  • addons/gmail — 1 commit
  • addons/internal — 1 commit
  • addons/ssh — 1 commit
  • backend/python — 1 commit

Notable commits

  • fix: [ui] fix(ui): show GPU memory use on the Settings page (#13162)
  • fix: fix(addons): read an update operation from a later session
  • fix: fix(addons): refresh the document skills proof after the work folder wording change
  • fix: fix(addons): refuse a Sandbox job start when its lease cannot be held
  • fix: fix(branding): version asset URLs so logo changes show at once
  • fix: fix(chats): do not ask the tools hook twice for each message
  • fix: fix(chats): keep the reasoning of earlier turns in the prompt
  • fix: fix(chats): keep the shell group provider when LocalAI serves its own tools
  • fix: fix(chats): keep the system prompt stable across chats so the prompt cache hits (#13153)
  • fix: fix(chats): start every shell in the chat's work folder and quote paths (#13212)
  • fix: fix(chats): write the whole sandbox policy shape and keep core add-on neutral
  • fix: fix(ci): get master green again (providerguard, UI e2e runner and spec) (#13148)
  • fix: fix(cloud-proxy): collapse nullable type unions in OpenAI tool schemas (#13165)
  • fix: fix(distributed): keep one idle replica when scaling down (#13201)
  • fix: fix(distributed): stage video reference media to the worker
  • fix: fix(docker): add an upstream fallback to the apt mirror helper
  • fix: fix(docker): run the archive apt steps through the fallback helper
  • fix: fix(downloader): parse the HuggingFace @revision suffix without panicking (#13179)
  • fix: fix(finetune): claim the export under the lock that checks it
  • fix: fix(gallery): declare the moss-tts-cpp codec and tokenizer options in the model library
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

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

Survey your own repository

mudler/LocalAI was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 17320ec2f16c836923b8f485e67566be2ae83338 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.