Skip to content
CAI
Software that uses CAICheck a score

astral-sh/uv

64.9

Adequate · 14 November 2026

294.3k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Python interpreter detection for musl-based Linux distributions

The \uv\ Python interpreter now detects musl-based Linux environments (such as Alpine) by introducing \\_musllinux.py\ to identify the musl runtime version and generate compatible platform tags. This complements the existing \\_manylinux.py\ module, which handles glibc-based systems, ensuring that \uv\ correctly identifies and manages Python interpreters across different Linux libc implementations.

uv · high confidence

Add cloneable seekable reader for concurrent ZIP extraction

The \uv-extract\ crate now includes a \CloneableSeekableReader\ component that enables concurrent, position-independent reads from ZIP archives. By using positioned reads (via \fs\_err\ on Unix and Windows) and maintaining independent buffers per clone, multiple parts of a ZIP file can be extracted simultaneously without race conditions on the file cursor, improving extraction performance for large or complex archives.

crates/uv-extract/src/vendor · high confidence

Added Git benchmark fixtures for reproducible performance testing

A new \GitFixture\ module has been added to the benchmark suite to provide reproducible Git source fetches. This module defines fixtures for \sampleproject\, \flask\, and \django\, pinning them to specific commits and tags. The \prepare\ method sets up isolated, bare Git repositories with deterministic packing (single-threaded delta search) and specific upload-pack configurations to ensure consistent benchmark results across runs.

_crates/uv-bench/benches/git\fixture · high confidence

Added internal development tools for sysconfig mapping and sdist testing

The uv-dev crate now includes scripts and configuration to support internal maintenance and testing workflows. A new shell script, sync\_sysconfig\_targets.sh, automates the update of Python-build-standalone references in the sysconfig mapping source code and regenerates the metadata. Additionally, test\_sdist\_building.sh provides an integration test that builds source distributions for tqdm and geoextract and verifies the resulting wheels with pip, while builder.dockerfile sets up an isolated Ubuntu environment for these builds. A .gitignore file excludes the generated test data, and a generated README documents the crate's internal status.

crates/uv-dev · high confidence

Centralized PEP 723 script discovery and unified item handling

The \uv-scripts\ crate now provides a dedicated \find\_scripts\ function that automatically discovers PEP 723 scripts within a workspace, intelligently skipping virtual environments, the cache, and \.git\ directories while respecting ignore files. This discovery logic is paired with a unified \Pep723Item\ abstraction that treats scripts from disk, \stdin\, and remote URLs consistently, allowing \uv run\ and other commands to handle inline-metadata scripts from any source with a single code path.

crates/uv-scripts/src · high confidence

Content-addressed wheel archives via directory hashing

The wheel extraction logic in uv-extract now computes a content-based directory hash for extracted archives. This enables deduplication of files in the wheel cache by identifying identical wheel contents regardless of their source, and supports content-addressed storage of wheel archives.

crates/uv-extract/src/dirhash · high confidence

Detect Homebrew installations to provide specific self-update instructions

When \uv self update\ is run on a Homebrew installation, the CLI now detects the install source and displays a hint with the correct update command (\brew update && brew upgrade uv\) instead of failing silently or suggesting a generic update method. This is implemented by inspecting the executable path for the Homebrew \Cellar/uv\ pattern in \crates/uv/src/install\_source.rs\ and integrating the detection into the error handling in \crates/uv/src/lib.rs\.

crates/uv/src · high confidence

Implement PyPI-specific trusted publishing service

Added a new \PyPIPublishingService\ implementation that handles PyPI's specific OIDC endpoints for audience discovery, token minting, and token burning. This enables uv to interact with PyPI's trusted publishing infrastructure by sending mint-token requests with the correct Content-Type and supporting token revocation, ensuring secure and compliant publishing workflows for PyPI registries.

_crates/uv-publish/src/trusted\publishing · high confidence

Initial repository scaffolding and developer tooling configuration

The repository is initialized with foundational configuration files that establish the project's development environment and release infrastructure. This includes \.editorconfig\ and \rustfmt.toml\ for consistent code formatting, \ruff.toml\ for Python linting, and \clippy.toml\ to enforce Rust code quality standards. Release and distribution are configured via \dist-workspace.toml\ (setting up \cargo-dist\ for multi-platform binaries and GitHub releases) and \hawk.toml\ (auditing public API visibility). Developer workflows are supported by \AGENTS.md\ (guidelines for AI-assisted contributions), \BENCHMARKS.md\ (performance comparison documentation), and a \Dockerfile\ for reproducible builds. Additionally, \SECURITY.md\ defines the project's security policy, and \.gitignore\/\.gitattributes\ manage version control hygiene.

(repo-wide) · high confidence

Internal crates uv-pep440 and uv-pep508 are now versioned independently

The \uv-pep440\ and \uv-pep508\ crates have been extracted from the main \uv\ repository and are now maintained as separate internal components with their own version numbers (currently 0.0.92). This change introduces independent changelogs, license files (Apache-2.0 and BSD), and READMEs for each crate, allowing them to be versioned and released separately from the main \uv\ tool while remaining internal dependencies.

crates/uv-pep440, crates/uv-pep508 · high confidence

Introduce PEP 792 project status markers

The \uv-pypi-types\ crate now includes types to represent PEP 792 project status markers, allowing the resolver to handle \active\, \archived\, \quarantined\, and \deprecated\ statuses. These statuses are parsed from the Simple API JSON response and integrated into the \PypiSimpleDetail\ and \PypiFile\ structures, enabling uv to respect project lifecycle states during dependency resolution.

crates/uv-pypi-types/src · high confidence

Introduce Python package for locating the uv binary and running it via \`python -m uv\`

The \python/uv\ package now provides a \find\_uv\_bin()\ function that locates the \uv\ executable by searching standard scripts directories, paths relative to the package root (supporting \--prefix\ and \--with\ installations), and the user scheme. Additionally, \python -m uv\ is supported, which automatically detects and preserves the current virtual environment and parent interpreter context, while suppressing tracebacks on Windows interrupts.

python · high confidence

Introduce \`uv audit\` service layer for OSV and PEP 792 checks

The \uv-audit\ crate now includes a service module that implements the core logic for vulnerability and project-status auditing. It adds support for querying the OSV (Open Source Vulnerabilities) database using batched queries to efficiently check dependencies, and implements PEP 792 adverse project status auditing to detect archived, quarantined, or deprecated packages. This establishes the backend infrastructure for the \uv audit\ command.

crates/uv-audit/src/service · high confidence

Introduce \`uv auth\` commands for managing credentials

Adds a new \uv auth\ command group with subcommands \login\, \logout\, \token\, and \dir\ to manage authentication credentials. Users can now store, retrieve, and remove credentials for services using a plaintext backend (with locking) or system keyring, supporting username/password, tokens, and URL-based credentials. A new \uv auth helper --protocol bazel\ command is also added to implement the Bazel credential helper protocol, allowing external tools to fetch credentials via stdin/stdout JSON exchange.

crates/uv/src/commands/auth · high confidence

Introduce \`uv publish\` with trusted publishing and retry support

This change introduces the \uv publish\ command, allowing users to upload Python distributions to package indexes. It supports authentication via username/password, keyring, and OIDC-based trusted publishing (for CI environments like GitHub Actions and GitLab CI). The implementation includes automatic retries with exponential backoff, progress reporting during hashing and uploads, and detailed error handling for common issues like invalid credentials or index mismatches.

crates/uv-publish/src · high confidence

Introduce \`uv-cache-info\` crate for dynamic cache key computation

A new \uv-cache-info\ crate has been added to handle the logic for computing dynamic cache keys, enabling users to incorporate Git tags, environment variables, and directory timestamps into their build cache invalidation. The implementation supports glob patterns for file matching, resolves Git references (including worktrees and packed refs) to determine commit and tag states, and uses file creation times (or inodes on Unix) for directory entries. This change provides the foundational mechanism for the \tool.uv.cache-keys\ configuration, allowing more granular control over when cached distributions are considered stale.

crates/uv-cache-info/src · high confidence

Introduce \`uv-pep508\` crate for dependency specifier parsing

The \uv-pep508\ crate has been introduced to handle PEP 508 dependency specifiers. It provides a new \Cursor\ for efficient string parsing, a \VerbatimUrl\ type that preserves the original user input while safely displaying URLs without credentials, and support for both named \Requirement\ and unnamed direct-URL requirements. The crate also tracks the \RequirementOrigin\ (e.g., file, project, or workspace) to improve error reporting and dependency resolution context.

crates/uv-pep508/src · high confidence

Introduce \`uv-requirements-txt\` crate for parsing requirements files

The \uv-requirements-txt\ crate has been added to provide a dedicated parser for \requirements.txt\ syntax. It supports PEP 508 requirements, recursive includes (\-r\), constraints (\-c\), editable installs (\-e\), and hash specifications (\--hash\). The implementation includes a vendored POSIX shell-compatible argument parser (\shquote\) to correctly handle quoting and escaping in file paths and options, and integrates with the existing client builder and source caching infrastructure for efficient file resolution.

crates/uv-requirements-txt/src · high confidence

Introduce automatic GPU accelerator detection and PyTorch index selection

The \uv-torch\ crate now automatically detects the system's GPU hardware (CUDA driver version, AMD GPU architecture, or Intel XPU) and selects the appropriate PyTorch package index. This allows users to use \--torch-backend=auto\ to seamlessly install GPU-accelerated PyTorch versions without manually specifying CUDA or ROCm versions, while still supporting explicit overrides via environment variables or CLI flags.

crates/uv-torch/src · high confidence

Introduce binary installation utilities for Ruff, Ty, and Uv

Added a new \uv-bin-install\ crate that provides the core logic for downloading and installing standalone binaries for Ruff, Ty, and Uv. This implementation supports fetching release metadata and binaries from an Astral mirror (with GitHub fallback for Ruff and Ty), applies default version constraints (e.g., Ruff 0.15.x), and handles platform-specific archive extraction.

crates/uv-bin-install/src · high confidence

Introduce centralized state storage for managed Python, tools, and credentials

The \uv-state\ crate now provides a \StateStore\ abstraction that manages persistent and temporary directories for user-facing data. This store organizes data into specific buckets for managed Python installations, installed tools, and credentials, using a fallback strategy that respects user-specified paths, legacy macOS directories for compatibility, XDG standards, or a local \.uv\ directory.

crates/uv-state/src · high confidence

Introduce content-addressable wheel caching via directory hashing

The \uv-extract\ crate now includes a new \dirhash\ module that computes deterministic BLAKE3 hashes for directory trees and archive contents. This enables content-addressable storage for wheel archives, allowing the package manager to identify and deduplicate identical packages based on their file contents rather than just their filenames or versions. The module provides both filesystem-based and in-memory hashing capabilities, integrating with the extraction pipeline to validate and cache wheels more efficiently.

crates/uv-extract/src · high confidence

Introduce core data types for dependency auditing

The \uv-audit\ crate now defines the foundational data structures used to represent audit findings, including \Dependency\, \Vulnerability\, \ProjectStatus\, and \AdverseStatus\. These types model resolved dependencies, vulnerability details (with support for multiple ID sources like CVE and PYSEC), and project health statuses such as archived or quarantined states, providing the internal data model for the upcoming \uv audit\ command.

crates/uv-audit/src · high confidence

Introduce dedicated resolver types crate for shared resolution data structures

A new \uv-resolver-types\ crate has been created to centralize data structures and logic shared between dependency resolution and lockfile handling. This includes the \AnnotatedDist\ struct for representing pinned packages with their resolved distributions, metadata, and universal markers, as well as the \ResolverOutput\ struct that holds the complete resolution graph. The crate also introduces \UniversalMarker\ to combine PEP 508 environment markers with conflict markers for extras and groups, enabling more precise marker evaluation during universal resolution. Additionally, it provides graph operations for marker reachability and conflict marker simplification, along with metadata handling types like \MetadataResponse\ and \DistributionMetadataIndex\.

crates/uv-resolver-types · high confidence

Introduce dedicated types for normalized package, extra, and dependency group names

The \uv-normalize\ crate now provides specific \PackageName\, \ExtraName\, and \GroupName\ types that enforce PEP 503/685/735 normalization rules (lowercasing and collapsing punctuation) at the type level. This change introduces \DefaultExtras\ and \DefaultGroups\ enums to support the \default-extras\ and \default-groups\ configuration options, and adds \PipGroupName\ to handle pip-compatible \path:group\ syntax for dependency group selection.

crates/uv-normalize/src · high confidence

Introduce fastid crate for 16-character secure unique IDs

The new \uv-fastid\ crate provides a nanoid-style ID generator producing 16-character strings (96 bits of entropy) using a 64-character alphabet. It exposes a single \Id\ type with a \secure()\ method for cryptographically secure generation, supports parsing from strings, and includes optional \serde\ serialization. The implementation replaces the previous \nanoid\ dependency and removes insecure APIs, encapsulating the ID logic within this dedicated type.

crates/uv-fastid/src · high confidence

Introduce global environment flags for build output control

A new global flags system has been added to the uv-flags crate, allowing users to control specific runtime behaviors via environment variables. This includes the HIDE\_BUILD\_OUTPUT flag, which enables users to omit build logs from the output, and the SKIP\_WHEEL\_FILENAME\_CHECK flag, which bypasses wheel filename validation. These flags are initialized once and can be checked globally throughout the application.

crates/uv-flags/src · high confidence

Introduce in-memory Git credential caching and GitHub API fast-path resolution

The \uv-git\ crate now maintains a process-wide cache for Git credentials, automatically storing and reusing authentication details for Git repository URLs to avoid repeated credential prompts or lookups during a single \uv\ invocation. Additionally, when resolving Git dependencies hosted on GitHub, \uv\ attempts to fetch the commit SHA directly via the GitHub REST API (the "fast path") instead of performing a full Git clone, which significantly speeds up resolution; this optimization automatically backs off if GitHub returns rate-limit errors (HTTP 403/429) and can be explicitly disabled via the \UV\_NO\_GITHUB\_FAST\_PATH\ environment variable.

crates/uv-git/src · high confidence

Introduce new uv-keyring crate for cross-platform credential storage

The \uv-keyring\ crate has been added to provide a unified, cross-platform interface for storing and retrieving secrets (such as publish credentials) using native system stores. This new component implements platform-specific backends for macOS (Keychain), Windows (Credential Manager), and Linux/FreeBSD/OpenBSD (Secret Service), while also including a mock store for testing. It replaces previous ad-hoc credential handling with a structured, thread-safe API that supports setting, getting, and deleting passwords and binary secrets, ensuring that sensitive data is persisted securely in the operating system's native keychain or credential manager.

crates/uv-keyring/src · high confidence

Introduce source annotations to track dependency origins

Users can now see exactly where each dependency in their resolution came from, such as whether it was pulled from a specific requirements file (\-r\), a constraints file (\-c\), an overrides file (\--override\), or a dependency group. This is implemented by adding \SourceAnnotation\ and \SourceAnnotations\ types to the distribution types crate, which record the \RequirementOrigin\ (file path, project, group, or workspace) for each package, enabling clearer diagnostic output when resolving conflicts or inspecting the dependency graph.

crates/uv-distribution-types/src · high confidence

Introduce the uv build backend

The \uv-build-backend\ crate provides the \uv\_build\ build backend, enabling users to build source distributions and wheels directly using uv. It supports configurable module roots and names, namespace packages, data file inclusion, and customizable source/wheel include and exclude globs, while generating standard metadata files and ensuring reproducible, cross-platform build outputs.

crates/uv-build-backend/src · high confidence

Introduce uv-build as a PEP 517 build backend

This change adds the \uv-build\ crate, which serves as the entry point for the new \uv\_build\ Python package acting as a PEP 517 build backend. It implements the standard build commands (\build-sdist\, \build-wheel\, \build-editable\, and metadata preparation) by delegating to the \uv\_build\_backend\ module, and includes logging configuration and preview feature support to integrate with the broader uv ecosystem.

crates/uv-build/src · high confidence

Introduce uv-cache-key crate for stable hashing and URL canonicalization

A new \uv-cache-key\ crate has been added to provide stable, cross-platform hashing and URL canonicalization for cache keys. It introduces a \CacheKey\ trait with implementations for standard types, tuples, and strings, alongside utilities to generate stable hex digest strings. The crate also defines \CanonicalUrl\ and \RepositoryUrl\ wrappers that normalize Git URLs by stripping credentials, trailing slashes, and \.git\ extensions, while supporting optional Git LFS discrimination to ensure cache keys remain distinct when LFS content differs.

crates/uv-cache-key/src · high confidence

Introduce uv-dirs crate for unified directory resolution

The new \uv-dirs\ crate consolidates directory lookup logic into a single public API, providing functions to resolve user-level executable, cache, state, and configuration directories. It implements a fallback chain for executable directories (checking override variables, \XDG\_BIN\_HOME\, \XDG\_DATA\_HOME/../bin\, and \\~/.local/bin\) and enforces XDG specification requirements by rejecting relative paths in XDG environment variables. System configuration resolution is also standardized, using \XDG\_CONFIG\_DIRS\ on Unix (falling back to \/etc/xdg\ and \/etc/uv\) and \%SYSTEMDRIVE%\\ProgramData\ on Windows.

crates/uv-dirs/src · high confidence

Introduce uv-once-map for concurrent job memoization

Added the \uv-once-map\ crate, providing \OnceMap\ and \RegisteredOnceMap\ to safely execute and memoize jobs (such as network requests) only once while allowing multiple concurrent callers to wait for and share the result. The implementation uses the \papaya\ concurrent hash map and Tokio \Notify\ primitives to handle parallel registration, waiting, and completion without blocking other tasks.

crates/uv-once-map/src · high confidence

Introduce uv-pep440 crate for PEP 440 version parsing and range conversion

The \uv-pep440\ library is now available to parse Python version specifiers (PEP 440) and convert them into PubGrub-compatible version ranges. This enables the resolver to handle complex version constraints, including pre-releases, local versions, and gap-preserving range-to-PEP 440 routines, while optimizing performance through reduced allocations and niche-filling in version structures.

crates/uv-pep440/src · high confidence

Introduce uv-version crate for centralized version reporting

A new uv-version crate has been added to provide a centralized function for retrieving the application version. This change establishes a single source of truth for version information, which is essential for consistent version reporting across the application, such as in user-agent strings.

crates/uv-version/src · high confidence

Introduction of DisplaySafeUrl to redact credentials in logs and output

The \uv-redacted\ crate now provides a \DisplaySafeUrl\ wrapper around the standard \url::Url\ type. This newtype automatically masks sensitive information—such as usernames, passwords, and specific query parameters like AWS signatures—when the URL is displayed or logged, preventing accidental credential leakage. It also includes logic to reject URLs with ambiguous authority components (where credentials might be confused with path segments) to ensure security and clarity in error messages. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

crates/uv-redacted/src · low confidence · unverified

Introduction of SmallString type for optimized immutable identifiers

A new \SmallString\ type has been added to the \uv-small-str\ crate to provide an optimized representation for immutable identifiers, backed internally by \ArcStr\. This type supports standard string operations, serialization via serde, archival via rkyv, and JSON schema generation via schemars, enabling more efficient memory usage for string data in contexts such as hash digests and deserialization.

crates/uv-small-str/src · high confidence

Introduction of the uv\_build Python package as a PEP 517/660 build backend

A new Python package, uv\_build, has been added to provide a minimal build backend compliant with PEP 517 and PEP 660. This package exposes standard hooks such as build\_sdist, build\_wheel, and build\editable, which internally invoke the uv CLI (specifically the 'uv build-backend' command) to perform the actual build operations. The package also includes a \\main\\_ module that prevents direct CLI usage, directing users to use 'uv build' or another build frontend instead, and includes type stubs to support static type checking.

crates/uv-build/python · high confidence

Introduction of the uv\_build standalone build backend crate

A new standalone Rust crate, \uv\_build\, has been added to provide a minimal build backend for uv. This component is a slimmed-down version of the main uv project, designed specifically to handle build operations without requiring network access (enforced by banning crates like \rustls\, \openssl\, and \reqwest\ in \deny.toml\). It includes its own licensing (Apache-2.0 and MIT), documentation, and configuration files, such as a \ruff.toml\ targeting Python 3.7 compatibility and a \rust-toolchain.toml\ specifying Rust 1.99.0.

crates/uv-build · high confidence

New \`DeserializeUntagged\` derive macro for single-pass untagged enum deserialization

The \uv-macros\ crate now exposes a \DeserializeUntagged\ derive macro that enables single-pass deserialization for untagged enums by dispatching variants based on their Serde input shape (string, bool, sequence, or map). This allows users to define enums where variants like \Name(String)\ or \Table { ... }\ are selected automatically during deserialization without requiring multiple parsing passes, supporting features such as \deny\_unknown\_fields\ and field renaming. The macro is implemented in \crates/uv-macros/src/deserialize\_untagged.rs\ and registered in \lib.rs\, with corresponding tests added in \tests/deserialize\_untagged.rs\ to verify shape-based dispatch and error handling. Also in this area: Added tests for DebugNoInline macro.

crates/uv-macros/tests · high confidence

New \`uv build\` command and build backend hooks

Users can now build Python distributions directly using the \uv build\ command, which exposes PEP 517 and PEP 660 hooks (such as \build\_sdist\, \build\_wheel\, and \build\_editable\) to generate source distributions and wheels. This change also introduces a new \uv\_build\_backend\ module that handles the actual artifact creation and metadata generation, allowing \uv\ to act as a build backend for projects.

crates/uv/src/commands · high confidence

New \`uv-dev\` subcommands for bytecode management and documentation generation

The \uv-dev\ CLI now includes commands to manage Python bytecode (\compile\ to generate \.pyc\ files, \clear\_compile\ to remove them) and a comprehensive suite of code-generation tools (\generate-all\, \generate-cli-reference\, \generate-options-reference\, \generate-json-schema\, \generate-env-vars-reference\, \generate-preview-features-reference\, \generate-dirhash-test-vectors\, \generate-scenario-tests\, and \generate-sysconfig-metadata\) that automate the creation of documentation, test vectors, and configuration schemas from source code.

crates/uv-dev/src · high confidence

New \`uv-requirements\` crate for unified requirements parsing and resolution

The \uv-requirements\ crate has been introduced to centralize the parsing and resolution of dependency specifications. It provides dedicated resolvers for expanding extras (\ExtrasResolver\), resolving transitive dependencies from direct URLs (\LookaheadResolver\), and extracting requirements from source trees like \pyproject.toml\ or \setup.py\ (\SourceTreeResolver\). The crate also handles the identification of input sources (\RequirementsSource\), the construction of the overall \RequirementsSpecification\, and the resolution of unnamed requirements (such as local wheels or archives) into named packages (\NamedRequirementsResolver\).

crates/uv-requirements/src · high confidence

New agent hooks for post-edit formatting and session initialization

Added new hooks under \agents/hooks\ to enhance the agent workflow: \post-edit-format.py\ automatically formats edited files (Rust, Python, and web assets) after agent edits, while \session-start.sh\ and \session-start-web.sh\ ensure required tools like \gh\, \clippy\, and \rustfmt\ are installed and configured at the start of a session.

agents/hooks · high confidence

New benchmarking scripts for dependency resolution and tool installation

Added new Python scripts in the benchmarking harness to measure performance against other packaging tools. The \resolver.py\ script benchmarks dependency resolution and installation speeds (cold, warm, and incremental scenarios) for \uv\ against \pip-tools\ (pip-compile). The \tools.py\ script benchmarks the \uv tool install\ workflow against \pipx\, covering cold installs, warm installs, and execution. These additions allow users to quantitatively compare \uv\'s performance with established alternatives in these specific workflows.

scripts/benchmark · high confidence

New commands for managing Python installations

The \uv-python-commands\ crate now exposes a suite of new commands for discovering, installing, listing, pinning, and uninstalling Python versions. Users can now use \uv python dir\ to view installation directories, \uv python find\ to locate interpreters, \uv python list\ to enumerate available and installed versions, \uv python pin\ to set version requirements, \uv python install\ to download and install specific Python versions, \uv python uninstall\ to remove them, and \uv python update-shell\ to ensure the executable directory is on the PATH.

crates/uv-python-commands · high confidence

New derive macros for debug formatting, options metadata, and preview features

The \uv-macros\ crate now provides several new procedural macros to automate code generation. \DebugNoInline\ generates \Debug\ implementations for enums that avoid inlining to reduce binary size. \OptionsMetadata\ derives metadata recording for configuration structs, enabling automatic documentation generation for options. \PreviewMetadata\ extracts documentation and aliases for preview feature enums, and \CombineOptions\ implements a \combine\ method for structs to merge configuration options.

crates/uv-macros/src · high confidence

New environment operations crate for shared project, script, and tool workflows

A new \uv-environment-operations\ crate has been introduced to centralize the logic for resolving, creating, and synchronizing Python environments. This module provides a unified \CachedEnvironment\ type for managing cached environments, an \InstallTarget\ enum to handle installation targets for projects, workspaces, and PEP 723 scripts, and a \sync\_from\_lock\ function to apply lockfile resolutions. It also includes a new \EnvironmentError\ type for detailed error reporting and an experimental malware checking feature that validates dependencies against the OSV database before installation.

crates/uv-environment-operations · high confidence

New installer module with bytecode compilation and parallel wheel installation

The \uv-installer\ crate has been restructured into a new modular installer that handles wheel preparation, installation planning, site-package satisfaction checks, and uninstallation. A key addition is the \compile.rs\ module, which introduces parallel bytecode compilation of installed packages using a pool of Python workers and a configurable timeout via the \UV\_COMPILE\_BYTECODE\_TIMEOUT\ environment variable. The \installer.rs\ module now manages the actual wheel installation into virtual environments, supporting configurable link modes, cache usage, and installer metadata. The \plan.rs\ module provides detailed diagnostics for incompatible wheels (e.g., ABI, platform, or Python version mismatches), while \satisfies.rs\ centralizes the logic for determining whether installed distributions meet current requirements, including build settings and URL freshness checks.

crates/uv-installer/src · high confidence

New options metadata library for documentation and serialization

A new \uv-options-metadata\ crate has been introduced to standardize how configuration options are described, documented, and serialized. It provides traits (\OptionsMetadata\, \Visit\) and types (\OptionSet\, \OptionField\) that allow configuration structures to automatically generate API reference documentation and structured metadata (including defaults, types, scopes, and deprecation status). This enables consistent generation of user-facing docs and programmatic access to option definitions across the tool.

crates/uv-options-metadata/src · high confidence

New scripts for CI snapshot management, release assembly, and build reproducibility

The scripts directory now includes several new automation tools: \apply-ci-snapshots.sh\ allows developers to download and apply pending insta snapshots from CI runs; \assemble-release-artifacts.py\ orchestrates the final release distribution by combining built wheels, signed artifacts, and source distributions; \build-trampolines.sh\ and its Docker helper ensure reproducible Windows trampoline builds by pinning the platform and normalizing PE timestamps; \check-cargo-bans.py\ enforces workspace dependency policies by checking for default feature requests and stale build-script allowlist entries; \check-release-artifact-sboms.sh\ verifies that release binaries contain required SBOM data; \check-trampoline-version-consistency.py\ ensures the \windows\ crate version matches between the main workspace and the trampoline crate; \bump-workspace-crate-versions.py\ automates patch version increments for workspace members while keeping binary crates stable; and \cargo.sh\/\cargo.cmd\ wrappers invoke \cargo auditable\ to embed SBOMs into builds.

scripts · high confidence

New scripts for automated PR review context and GitHub Actions thread import

Added two new shell scripts to the agents/scripts directory to support code quality reviews. collect-pull-request-review-context.sh gathers pull request metadata, diffs, and review comments into a structured context directory for automated analysis. load-github-action-thread.sh downloads Codex rollout artifacts from GitHub Actions runs and imports them as interactive threads via the Codex app-server, enabling the reuse of previous execution contexts.

agents/scripts · high confidence

New uv-command-support crate for shared CLI primitives

The \uv-command-support\ crate has been introduced to centralize shared command-line interface logic. It provides a \Printer\ enum to manage output verbosity (Silent, Quiet, Default, Verbose, NoProgress) and control standard streams, a \ProgressReporter\ for handling concurrent download and build progress bars, and an \OutputWriter\ that multicasts output to both the terminal and an optional file. Additionally, it includes utilities for reading environment files, managing child process execution with signal handling, and automatically updating shell configuration files to ensure executables are in the PATH.

crates/uv-command-support · high confidence

New uv-fs crate for filesystem operations

The \uv-fs\ crate introduces a new, dedicated module for filesystem operations, consolidating logic previously scattered across the codebase. It provides utilities for atomic file linking and copying with platform-specific optimizations (reflinks on macOS/Linux, hardlinks elsewhere), safe file locking with configurable timeouts, and robust path handling including simplified display and portable serialization. The crate also adds support for reading UTF-16 files transparently, fine-grained disk space accounting on macOS and Linux, and safe temporary file creation that handles long Windows paths.

crates/uv-fs/src · high confidence

New uv-python-managed crate with embedded, compressed Python release catalog

This change introduces the \uv-python-managed\ crate, which handles the download, storage, and maintenance of Python installations. It embeds a comprehensive catalog of Python releases (including CPython 3.16.0a1 and various 3.13/3.14/3.15 versions) as a compressed \download-metadata.json.zst\ file generated at build time, ensuring smaller binary sizes while providing up-to-date installation metadata for users.

crates/uv-python-managed · high confidence

New uv-shell crate for shell detection, configuration, and path management

The \uv-shell\ crate has been introduced to centralize shell-related logic. It provides robust shell detection (supporting Bash, Zsh, Fish, PowerShell, Cmd, Ksh, Csh, and Nushell) with fallbacks to parent process inspection on Unix. The crate manages shell configuration files (e.g., \.bashrc\, \.zshenv\) to append commands safely, handling creation and idempotent updates. On Windows, it enables legacy script execution (\.ps1\, \.bat\, \.cmd\) via \WindowsRunnable\ and manages the user \PATH\ environment variable in the registry, broadcasting \WM\_SETTINGCHANGE\ notifications to ensure other processes pick up the changes. It also includes shell-specific path quoting utilities for POSIX and Windows shells.

crates/uv-shell/src · high confidence

New uv-test crate for shared integration test infrastructure

The \uv-test\ crate has been introduced to centralize shared test utilities, replacing scattered helpers across the repository. It provides a \TestContext\ struct for managing temporary directories, cache directories, and virtual environments, along with macros to resolve the \uv\ binary path at runtime. The crate also includes a local \HttpServer\ wrapper, a \FindLinksServer\ for serving PEP 503 flat link pages, a \PackageServer\ for mocking package indexes with integrity checks, and helpers for generating test archives and asserting path/link states.

crates/uv-test/src · high confidence

New uv-windows crate for Windows process lifecycle and exception handling

A new \uv-windows\ crate has been introduced to centralize Windows-specific utilities. It provides Job Object management to ensure child processes are terminated when their parent wrapper (like \uvx.exe\) is killed, preventing orphaned processes. It also installs a console control handler to ignore Ctrl+C in wrappers so children can handle signals, and adds an unhandled exception handler to display crash details and register dumps on Windows. Additionally, it includes a Wine detection utility to allow fallback behavior for filesystem operations like symlinks.

crates/uv-windows/src · high confidence

New uvx and uvw binary wrappers for tool execution and background invocation

The \crates/uv/src/bin\ directory now includes dedicated entry points for \uvx\ and \uvw\. The \uvx\ binary acts as a wrapper that locates the main \uv\ executable (supporting suffixed versions like \uv@1.2.3\) and executes it with the \tool uvx\ subcommand, enabling direct tool invocation. The \uvw\ binary similarly locates and spawns \uv\ but is configured on Windows to run without a console window, allowing it to operate in the background. Both wrappers use \exec\-style spawning to replace the process image, ensuring proper signal handling and exit code propagation.

crates/uv/src/bin · high confidence

Reproducible Windows trampoline build environment

The uv-trampoline crate now includes a Dockerfile and pinned nightly Rust toolchain (nightly-2026-05-06) to enable reproducible cross-compilation of Windows executables. This change ensures that the generated trampoline binaries are built in a consistent, auditable environment with pinned SDK and CRT versions, rather than relying on local system toolchains.

crates/uv-trampoline · high confidence

Rewritten authentication subsystem with explicit credential caching and cloud signing support

The \uv-auth\ crate has been completely rewritten to introduce a structured authentication middleware and explicit credential caching. Users benefit from a new \CredentialsCache\ that stores and retrieves credentials by realm and URL, improving reliability for repeated requests. The system now supports an \AuthPolicy\ (auto, always, never) for index configuration, allowing finer control over when authentication is attempted. Additionally, the rewrite adds native support for request signing for AWS S3, Google Cloud Storage (GCS), and Azure endpoints, as well as Bearer token authentication and Hugging Face token integration via environment variables. The \KeyringProvider\ is now async and supports both native system keyrings and subprocess-based keyring commands, while the \TextCredentialStore\ provides a TOML-based backend for storing credentials with support for multiple usernames per service.

crates/uv-auth/src · high confidence

Structured error hints and terminal-aware line wrapping

The error reporting system now supports structured, user-facing hints that are rendered after the main error message, prefixed with 'hint:'. These hints can be assigned a display order (First, Any, Last) to control their sequence, and duplicate hints are deduplicated while preserving the earliest ordering. Additionally, error output now features first-party line wrapping that respects terminal width (via the COLUMNS environment variable or terminal detection) and can be disabled with UV\_NO\_WRAP, ensuring long error messages and hints wrap cleanly at word boundaries without breaking words.

crates/uv-errors/src · high confidence

Support for PEP 735 dependency groups

The \uv-workspace\ crate now reads and resolves PEP 735 dependency groups defined in \pyproject.toml\ under the \\[dependency-groups\]\ table. It flattens these groups (including \include-group\ references) into concrete requirement lists, applies per-group \requires-python\ constraints, and integrates them with the legacy \tool.uv.dev-dependencies\ for backward compatibility. This enables users to organize dependencies into named, reusable groups with their own Python version requirements.

crates/uv-workspace/src · high confidence

Virtual environment creation now patches distutils and supports relocatable environments

The \uv-virtualenv\ crate now installs a runtime patch for \distutils\ and \setuptools\ (via \\_virtualenv.py\) to prevent global configuration files from hijacking installation paths in virtual environments, specifically for Python versions prior to 3.10. Additionally, the virtual environment creation logic now supports relocatable environments, allowing activation scripts to function correctly even if the virtual environment directory is moved or symlinked.

crates/uv-virtualenv/src · high confidence

Windows binaries now include a compatibility manifest

The uv binary for Windows now embeds a manifest that enables long-path support (allowing paths longer than 260 characters, subject to registry settings), declares compatibility with Windows 7 through Windows 10, and sets the execution level to 'AsInvoker' to disable UAC virtualization. This change improves compatibility and usability on Windows systems without requiring manual configuration.

crates/uv · high confidence

Architecture

Centralized configuration and resolution options in uv-configuration

The \uv-configuration\ crate now serves as the single source of truth for command-line and configuration settings, consolidating previously scattered logic. This change introduces dedicated modules for managing build options (no-build/no-binary), dependency group inclusion/exclusion, version bounds for \uv add\, active virtual environment handling, and resolution constraints. Users benefit from a unified configuration layer that ensures consistent application of settings like \--no-build\, \--only-dev\, and \exclude-newer\ across all uv commands.

crates/uv-configuration/src · high confidence

Extract pip commands into the uv-pip-commands crate

The pip-related commands (install, sync, compile, check, freeze, list, show, tree, and uninstall) have been extracted into a dedicated \uv-pip-commands\ crate. This refactoring centralizes the implementation of these commands, improving code organization and maintainability without changing user-facing behavior.

crates/uv-pip-commands · high confidence

Extract publish logic into a dedicated crate

The publish command implementation has been extracted from the main crate into a new \uv-publish-commands\ crate. This refactoring introduces a dedicated \PublishReporter\ for handling progress output during uploads and hash checks, and centralizes the credential gathering and client configuration logic for publishing distributions.

crates/uv-publish-commands · high confidence

Extract tool commands into a dedicated crate

The tool management commands (install, run, list, uninstall, audit, upgrade, dir) have been extracted from the main binary into a new \uv-tool-commands\ crate. This refactoring isolates the implementation of tool-related operations, including the parsing of tool requests (e.g., \ruff@latest\), environment resolution, and lockfile handling, into a modular structure that can be reused by other parts of the application.

crates/uv-build-commands · high confidence

Extracted lockfile discovery, validation, and resolution into a dedicated crate

The lockfile management logic has been reorganized into the new \uv-lock-operations\ crate, which now centralizes the discovery, validation, and resolution workflows. This change introduces a \DiscoveredProject\ enum that allows the system to identify a project either from its source manifests or from a \FrozenWorkspace\ (a lockfile used when the workspace manifest is missing, enabled via the \FrozenLockfile\ preview feature). It also adds a \LockError\ type with specific error variants for lockfile policy violations, such as schema version mismatches, missing lockfiles, and overlapping environment markers, providing clearer feedback when lockfile operations fail. Also in this area: PEP 723 scripts without dependencies now reuse existing environments.

crates/uv-lock-operations · high confidence

Extracted tool command logic into a dedicated uv-tool-commands crate

The implementation logic for managing installed tools has been extracted from the main crate into a new \uv-tool-commands\ crate. This new module provides the core functionality for the \uv tool\ subcommands, including installing, running, listing, upgrading, and uninstalling tools, as well as auditing them for vulnerabilities. It also handles the resolution of tool requirements and the management of tool-specific Python environments.

crates/uv-tool-commands · high confidence

Introduce BuildDispatch as the central build context implementation

The \uv-dispatch\ crate now provides the \BuildDispatch\ struct, which implements the \BuildContext\ trait to coordinate package building, resolution, and installation while avoiding cyclic crate dependencies. This component manages build isolation, concurrency limits, hash checking for build dependencies, and configuration settings, serving as the core infrastructure for the build pipeline.

crates/uv-dispatch/src · high confidence

Introduce internal types for build isolation, hashing, and build context

The \uv-types\ crate now exposes core internal types that govern how uv manages builds and dependencies. Users benefit from more robust build isolation controls via the new \BuildIsolation\ enum, which distinguishes between isolated builds, shared environments, and package-specific shared environments. Hash verification and collection are centralized in the \HashStrategy\, enforcing stricter policies such as rejecting MD5-only hashes and separating archive from metadata hash validation. The \BuildContext\ trait and \BuildArena\ provide the infrastructure for dispatching builds and caching in-process results, while \ResolvedRequirements\ and \RequestedRequirements\ structure the output of the resolver with associated hash policies.

crates/uv-types/src · high confidence

Introduce new HTTP client architecture with caching and retry logic

The \uv-client\ crate has been restructured to provide a new, centralized HTTP client infrastructure. This change introduces a \BaseClient\ and \BaseClientBuilder\ for constructing canonical, configured HTTP clients with support for custom proxies, authentication middleware, and retry policies. It adds a \CachedClient\ that handles HTTP caching, including support for both \serde\ and \rkyv\ serialization, and offloads cache reads and decoding to dedicated blocking tasks to avoid main-thread contention. The update also includes a \FlatIndexClient\ for handling \--find-links\ directories and URLs, a \RegistryClient\ for interacting with package indexes, and improved error handling with RFC 9457 Problem Details support. Additionally, it adds a \LineHaul\ module to enrich the User-Agent string with system and installer metadata for PyPI statistics.

crates/uv-client/src · high confidence

Python discovery logic extracted into a dedicated crate

The Python installation discovery, selection, and version-file handling logic has been extracted from the main codebase into a new \uv-python-discovery\ crate. This change introduces a modular architecture where the crate exposes specific components for interpreter discovery (\discovery.rs\), installation management (\installation.rs\), project-level requirement validation (\project.rs\), and PEP 723 script compatibility (\script.rs\). Users benefit from a cleaner separation of concerns, with the new crate handling the resolution of Python versions from sources like \.python-version\ files, \pyproject.toml\ requirements, and system paths, while providing structured error reporting for selection failures.

crates/uv-python-discovery · high confidence

Refactor metadata resolution into a dedicated module

The metadata resolution logic in \uv-distribution\ has been reorganized into a new \metadata\ module containing \build\_requires.rs\, \dependency\_groups.rs\, \lowering.rs\, \mod.rs\, and \requires\_dist.rs\. This change extracts the requirement-lowering logic (which applies \tool.uv.sources\ and \tool.uv.index\ configurations) into a shared \LoweredRequirement\ implementation, allowing both standard dependencies and dependency groups to be resolved consistently. It also introduces specific error types for group-related lowering failures and centralizes the handling of workspace discovery and credential caching during metadata parsing.

crates/uv-distribution/src/metadata · high confidence

Refactor settings into a new uv-settings crate

Configuration loading, merging, and resolution logic has been moved into a dedicated \uv-settings\ crate. This introduces a \Combine\ trait for hierarchical config merging (where deeper directories take precedence, and arrays are joined), separates resolved installer and resolver settings into \resolved.rs\, and defines the \Options\, \FilesystemOptions\, and \EnvironmentOptions\ structures in \settings.rs\. Users benefit from more precise configuration discovery (including warnings for invalid \pyproject.toml\ during traversal) and consistent handling of settings across \uv.toml\ and \pyproject.toml\ files.

crates/uv-settings/src · high confidence

Refactored resolver internals into modular components

The \uv-resolver\ crate has been restructured to improve maintainability and separation of concerns. The core resolution logic is now split into dedicated modules: \candidate\_selector\ handles version selection and preference application, \prioritized\_distribution\ manages artifact compatibility and ranking, \fork\_indexes\ and \fork\_urls\ track index and URL consistency within resolution forks, and \pins\ ensures consistent artifact selection within a fork. Error reporting and derivation trees are centralized in \error.rs\, while \manifest.rs\ defines the input requirements, constraints, and preferences. This refactoring isolates specific resolver behaviors (like fork state management and candidate prioritization) into their own types, making the resolver easier to extend and debug without changing the external resolution behavior.

crates/uv-resolver/src · high confidence

Refactored resolver internals into modular submodules

The resolver logic in \crates/uv-resolver/src/resolver\ has been reorganized into distinct modules (e.g., \availability\, \batch\_prefetch\, \derivation\, \environment\, \fork\_map\, \index\, \indexes\, \package\_source\, \provider\, \reporter\). This change extracts specific concerns—such as batch prefetching, derivation chain building, fork-scoped maps, and metadata availability tracking—into their own files to improve code maintainability and separation of concerns, without altering the external resolution behavior.

crates/uv-resolver/src/resolver · high confidence

Refactored wheel installation into a modular, split architecture

The wheel installation logic in \uv-install-wheel\ has been restructured to separate the core installation workflow from the file-linking mechanics. A new \install.rs\ module now orchestrates the high-level installation steps—such as validating the wheel, extracting files, writing entry points, and updating the RECORD file—while a dedicated \linker.rs\ module handles the low-level file operations and conflict detection. This change improves code organization and maintainability without altering the user-facing installation behavior.

crates/uv-install-wheel/src · high confidence

Behavioural changes

22 commits (1 fix) modifying crates/uv-project-commands

A change to existing behaviour in crates/uv-project-commands — 22 commits (1 fix), 19 files: “Split Python types, interpreter queries, management, and discovery (\#22301)”; “Handle project names starting with a digit in \uv init\ (\#23022)”; “Extract project commands into uv-project-commands (\#22199)”; and 19 more (refs \#22301, \#23022, \#22199, \#22297, \#23082, …).

crates/uv-project-commands · medium confidence · unverified

4 commits (0 fixes) modifying crates/uv-audit-operations

A change to existing behaviour in crates/uv-audit-operations — 4 commits, 4 files: “Extract shared lockfile audit and reporting workflows (\#22192)”; “Use owning crate names for shared workflow logs (\#22288)”; “Deduplicate aliased OSV findings in uv audit (\#22990)”; and 1 more (refs \#22192, \#22288, \#22990, \#22599).

crates/uv-audit-operations · medium confidence · unverified

4 commits (0 fixes) modifying crates/uv-project-edit/src

A change to existing behaviour in crates/uv-project-edit/src — 4 commits, 1 file: “Allow an empty inline sources table in uv remove (\#23012)”; “Escape literal paths when adding workspace members (\#23008)”; “Preserve inline comments when updating an existing dependency group (\#23017)”; and 1 more (refs \#23012, \#23008, \#23017, \#22337).

crates/uv-project-edit/src · medium confidence · unverified

4 commits (1 fix) modifying crates/uv-python-interpreter/python

A change to existing behaviour in crates/uv-python-interpreter/python — 4 commits (1 fix), 9 files: “Split Python types, interpreter queries, management, and discovery (\#22301)”; “Detect AArch64 versions for wheel variants (\#22949)”; “Support x86-64 microarchitecture levels in wheel variants (\#22832)”; and 1 more (refs \#22301, \#22949, \#22832, \#23089).

crates/uv-python-interpreter/python · medium confidence · unverified

5 commits (0 fixes) modifying crates/uv-workspace-commands

A change to existing behaviour in crates/uv-workspace-commands — 5 commits, 5 files: “Split Python types, interpreter queries, management, and discovery (\#22301)”; “Allow requesting a workspace metadata schema version (\#22958)”; “Include installed packages in workspace metadata (\#22395)”; and 2 more (refs \#22301, \#22958, \#22395, \#22638, \#22198).

crates/uv-workspace-commands · medium confidence · unverified

62 commits (3 fixes) modifying crates/uv-lock

A change to existing behaviour in crates/uv-lock — 62 commits (3 fixs), 26 files: “Split Python types, interpreter queries, management, and discovery (\#22301)”; “Revert optional-extra activation tracking in exports (\#22750)”; “Separate Git and ordinary URL normalization (\#23082)”; and 59 more (refs \#22301, \#22750, \#23082, \#21139, \#21739, …).

crates/uv-lock · medium confidence · unverified

7 commits (0 fixes) modifying crates/uv-distribution/src/variant

A change to existing behaviour in crates/uv-distribution/src/variant — 7 commits, 5 files: “Add static constructors for wheel variant identifiers (\#22862)”; “Better description for nvidia wheel variant provider (\#22858)”; “Detect AArch64 versions for wheel variants (\#22949)”; and 4 more (refs \#22862, \#22858, \#22949, \#23121, \#22832, …).

crates/uv-distribution/src/variant · medium confidence · unverified

Added unique-key validation for TOML map deserialization

The uv-toml crate now includes a \deserialize\_unique\_map\ helper that rejects TOML files containing duplicate keys in map structures. This prevents silent overwrites and ensures data integrity when parsing configuration files, aligning with stricter validation practices for project metadata.

crates/uv-toml/src · high confidence

Automatic adjustment of open file descriptor limits on Unix

uv now automatically raises the soft open file descriptor limit to the maximum allowed (capped at 1,048,576) at startup on Unix systems. This prevents "too many open files" errors that can occur when uv schedules high concurrency, ensuring that child processes spawned by commands like \uv run\ inherit sufficient file descriptors without requiring manual shell configuration.

crates/uv-unix/src · high confidence

Build script now tracks Git commit metadata and supports linked worktrees

The \uv-cli\ crate now includes a \build.rs\ script that embeds Git commit hash, date, and tag information into the binary, but only for release builds or when explicitly enabled via the \UV\INTERNAL\\_BUILD\_GIT\_INFO\ environment variable. This change prevents unnecessary recompilations during development by omitting Git metadata by default. Additionally, the build script now correctly handles Git linked worktrees by detecting \.git\ files pointing to external directories and watching the appropriate HEAD and reference files, ensuring accurate versioning in worktree-based development workflows.

crates/uv-cli · high confidence

Centralized environment variable definitions and static configuration in uv-static

The \uv-static\ crate now serves as the single source of truth for all \uv\ environment variables, providing a centralized \EnvVars\ struct that declares every supported variable (such as \UV\_OFFLINE\, \UV\_PYTHON\, and \UV\_INDEX\) along with their introduction versions. This change introduces a generated \known\_stdlib.rs\ module that lists Python standard-library packages to improve diagnostic accuracy when users attempt to install standard library modules as packages. Additionally, the crate exposes static configuration helpers, including a \TarBackend\ enum that allows users to switch between the default \tar-codec\ and the legacy \tokio-tar\ backend via the \UV\_LEGACY\_TAR\_BACKEND\ environment variable, and utilities to read the user-configured Astral mirror URL from \UV\_ASTRAL\_MIRROR\_URL\.

crates/uv-static/src · high confidence

Centralized global preview feature state management

The \uv-preview\ crate now provides a centralized, thread-safe mechanism for managing global preview feature flags. It introduces a finalized state model where preview configurations are set during startup and locked to prevent modification, ensuring consistent behavior across the application. This change replaces manual, scattered bit assignments with a unified API (\set\, \finalize\, \is\_enabled\) that supports both normal runtime operation and isolated testing via a dedicated test mode with feature guards.

crates/uv-preview/src · high confidence

Centralized thread pool and stack size configuration

The \uv-threads\ crate now provides a unified entry point for initializing the global Rayon thread pool. Users benefit from consistent thread stack sizing (defaulting to 4MB, configurable via \UV\_STACK\_SIZE\ or \RUST\_MIN\_STACK\ environment variables) and lazy initialization of the parallelism pool, which helps prevent stack overflows across different platforms.

crates/uv-threads · high confidence

Custom logging format with ANSI stripping

The uv logging crate now uses a custom \UvFormat\ implementation for \tracing-subscriber\ that controls the display of timestamps, log levels, and span names, applying specific colors for each level when ANSI is enabled. Additionally, the \uv\_fields\ function ensures that any ANSI escape sequences embedded in log field values are stripped before output, preventing raw control codes from appearing in the terminal output.

crates/uv-logging/src · high confidence

Excludes FreeBSD from jemalloc support

The performance memory allocator crate now explicitly excludes FreeBSD from using the tikv-jemallocator global allocator. While Windows continues to use mimalloc and other supported platforms (x86\_64, aarch64, powerpc64) use jemalloc, FreeBSD builds will no longer link against the custom performance allocator, reverting to the system default for that platform.

crates/uv-performance-memory-allocator/src · high confidence

Extract installation workflows into a dedicated operations crate

The installation logic has been reorganized into a new \uv-install-operations\ crate, separating bytecode compilation, editable mode application, error handling, and reporting from the core installer. This refactoring introduces a structured \Changelog\ to track installed, uninstalled, and reinstalled packages, enabling more precise user-facing feedback during \uv sync\ and \uv install\ operations, including detailed progress reporting and standardized error messages for compilation and environment updates.

crates/uv-install-operations · high confidence

Extracted resolution and installation workflows into a dedicated operations crate

The dependency resolution and installation logic has been extracted from the main resolver into a new \uv-resolve-operations\ crate. This change introduces a structured \Error\ enum to represent resolution failures (such as unsatisfiable constraints, missing extras, or scoped override issues) with typed, user-facing messages and diagnostic hints. It also provides dedicated workflows for reading requirements from various sources (including \requirements.txt\, \pylock.toml\, and lockfiles) while respecting upgrade strategies, and introduces a \LatestClient\ to fetch the most recent compatible package versions from indexes. Additionally, the crate standardizes progress reporting for resolution and version fetching, and provides utilities for computing resolution markers and platform tags based on the target Python environment.

crates/uv-resolve-operations · high confidence

HTTP cache policy implementation updated to RFC 9111 with zero-copy deserialization

The HTTP cache control logic in \crates/uv-client/src/httpcache\ has been rewritten to align with RFC 9110 and RFC 9111 semantics. The new implementation introduces a \CacheControl\ struct that parses and stores cache directives (such as \max-age\, \no-store\, and \immutable\) using packed bitflags and integers. To optimize performance, the cache policy now leverages \rkyv\ for zero-copy deserialization, allowing the system to determine cache freshness without fully deserializing cached data in the fast path. This change affects how uv validates and reuses cached HTTP responses from sources like PyPI.

crates/uv-client/src/httpcache · high confidence

Improved build failure hints for missing dependencies

When a build fails due to a missing module, uv now provides more actionable error messages. Specifically, it suggests installing \meson-python\ when that build backend is missing, and generally recommends using \extra-build-dependencies\ to resolve other missing module issues during the build process.

crates/uv-build-frontend/src/pipreqs · high confidence

Improved dependency resolution error messages and cache integrity

The distribution subsystem now provides clearer, more actionable error messages when dependency resolution fails, including derivation chains that explain why a specific package version was selected and suggestions for common typos (e.g., \sklearn\ vs \scikit-learn\). Additionally, wheel extraction now validates and heals the \RECORD\ file to ensure cache integrity, and the cache system supports content-addressed storage for improved reliability.

crates/uv-distribution/src · high confidence

Introduce cross-platform glob filtering for build backend

The build backend now uses a new \uv-globfilter\ crate to handle include/exclude patterns, implementing PEP 639 portable glob syntax. This change replaces previous glob handling with a custom implementation that supports cross-language compatibility, including backslash escaping in uv-specific mode, and uses a DFA-based prefilter to efficiently skip directory trees that cannot match the specified patterns during source distribution builds.

crates/uv-globfilter/src · high confidence

Introduce dedicated wheel and source distribution filename parsing

The \uv-distribution-filename\ crate now provides structured types for parsing and validating wheel and source distribution filenames, including support for PEP 803 build tags, expanded wheel tag compatibility checks, and \.egg-info\ parsing. This change ensures stricter validation of filename segments, proper handling of all CPython ABI tag suffixes, and more accurate compatibility checks by preserving expanded wheel tag rows rather than combining distinct rows. Users will see improved diagnostics for invalid distribution filenames and more reliable wheel selection based on platform and Python version compatibility.

crates/uv-distribution-filename/src · high confidence

Introduce structured tool receipts and environment tracking

The \uv-tool\ crate now manages installed tools using explicit \uv-receipt.toml\ files that record installation metadata, including requirements, constraints, overrides, exclusions, build constraints, Python version requests, and entry points. This change introduces the \ToolReceipt\ and \Tool\ structs to serialize and deserialize this state, replacing previous ad-hoc storage. It also adds the \ToolEnvironment\ wrapper to safely retrieve tool versions from the underlying Python environment and the \InstalledTools\ collection to enumerate, validate, and manage tool directories based on settings like \UV\_TOOL\_DIR\. Invalid tool directories are now skipped with warnings, and missing or malformed receipts are handled gracefully rather than causing hard failures.

crates/uv-tool/src · high confidence

Introduce uv-build-frontend crate with improved build error reporting

The build frontend logic has been moved into a dedicated \uv-build-frontend\ crate, consolidating wheel building and source distribution handling. This change introduces significantly improved error messages for build failures, including specific hints for missing build dependencies (suggesting \extra-build-dependencies\ or \--no-build-isolation\) and better context for missing headers or linker errors. It also adds validation for build backend paths and detects cyclic build dependencies, providing clearer feedback when a project's build configuration is invalid.

crates/uv-build-frontend/src · high confidence

Introduce uv-git-types crate with strict Git URL parsing and LFS support

The \uv-git-types\ crate has been extracted to provide core types for Git repository references, introducing stricter validation and new capabilities. \GitOid\ now strictly requires exactly 40 hexadecimal characters for commit hashes, rejecting shorter or malformed IDs. Git URL parsing enforces percent-encoding for revisions containing special characters and rejects unsupported schemes, while also redacting credentials in displayed URLs. A new \GitHubRepository\ helper simplifies parsing GitHub-specific URLs, and Git LFS support is added as an opt-in feature controlled by the \UV\_GIT\_LFS\ environment variable.

crates/uv-git-types/src · high confidence

Introduce validated source archive extraction and built wheel metadata tracking

Source distribution handling now validates archive integrity before caching: the new \ValidatedSourceArchive\ extracts archives into a staging directory, computes and verifies hashes (including size checks and existing cache hashes), and only persists the result if validation passes. Additionally, \BuiltWheelMetadata\ and \BuiltWheelFile\ are introduced to track the path, filename, hashes, and build information of wheels built from source distributions, enabling the system to locate and verify compatible built wheels in the cache.

crates/uv-distribution/src/source · high confidence

Managed Python installations now patch sysconfig and pkg-config files for portability

The managed Python setup process now automatically patches the \\sysconfigdata\\ and \.pc\ (pkg-config) files within the installed Python distribution. This ensures that compiler paths (such as \gcc\ or \clang\) are replaced with generic names like \cc\ and \c++\, and that absolute installation prefixes are adjusted to the actual install location. This change improves compatibility with build tools and environments that expect portable, non-hardcoded paths in Python's configuration data.

crates/uv-python-managed/src/sysconfig · high confidence

New cache-based index for registry and direct URL distributions

The distribution subsystem now uses dedicated \BuiltWheelIndex\ and \RegistryWheelIndex\ structures to manage cached wheels. These indexes resolve cached distributions by reading revision pointers and validating them against hash policies, archive sizes, and build settings (including \config-settings\ and extra build requirements). This change centralizes the logic for locating cached wheels from both registry sources and direct URLs, ensuring that cached builds are only reused when their build configuration and integrity checks match the current request.

crates/uv-distribution/src/index · high confidence

New interactive console prompt functions for confirmation, password, username, and text input

The \uv-console\ crate now provides a set of custom, lightweight interactive prompt functions (\confirm\, \confirm\_with\_hint\, \password\, \username\, and \input\) that replace the previous dependency on \dialoguer\. These functions handle user interaction directly via the terminal, including specific behaviors such as immediate response to 'y'/'n' keys in confirmations, explicit handling of Ctrl-C to exit cleanly without panicking, and custom cursor management for text input. This change gives users more predictable and responsive interactive experiences when \uv\ requires input, such as during authentication or package addition workflows.

crates/uv-console/src · high confidence

New uv-platform crate for unified OS, architecture, and libc detection

Platform detection logic has been extracted into a dedicated \uv-platform\ crate, consolidating OS, architecture, and libc identification into a single \Platform\ type. This change introduces support for new platform tags including iOS, Pyodide, and PyEmscripten (PEP 783), and improves Linux ARM detection by reading \/proc/cpuinfo\ to correctly identify hard-float support on AArch64 kernels running ARMv7 userspace. It also adds Windows x86-32 emulation support for ARM64 hosts and ensures Windows OS type and version detection aligns with previous behavior.

crates/uv-platform/src · high confidence

PEP 508 markers now use Algebraic Decision Diagrams for evaluation

The marker evaluation engine in \uv-pep508\ has been rewritten to use Algebraic Decision Diagrams (ADDs) instead of the previous representation. This change introduces a new internal structure where marker trees are canonicalized and managed via a global interner, enabling efficient conjunction, negation, and disjointness checks. For users, this means marker parsing, validation, and resolution should be more robust and performant, with improved handling of complex marker combinations and deprecated marker aliases.

crates/uv-pep508/src/marker · high confidence

Packse scenario tests now use a local mock index

Tests relying on Packse scenarios now use a local mock index instead of external network calls. The \uv-test\ crate includes a new \packse\ module that vendors scenario definitions and serves them via a local wiremock server, allowing tests to run faster and without network dependencies. Also in this area: Simplified artifact settings deserialization in uv-test.

crates/uv-test/src/packse · high confidence

Redesigned cache directory structure and storage accounting

The cache implementation has been restructured to improve organization and reporting. The cache directory now defaults to a dedicated \cache\ subdirectory (e.g., \.../uv/cache\), and a migration is automatically performed for existing installations to move legacy data into this new location. Additionally, \uv cache clean\ now provides detailed storage accounting, reporting the exact number of files and directories removed along with a byte count of the reclaimed space.

crates/uv-cache/src · high confidence

Refactor CLI argument parsing into dedicated modules

The CLI argument parsing logic in \crates/uv-cli/src\ has been reorganized into distinct modules: \comma.rs\ introduces a \CommaSeparatedRequirements\ parser that correctly handles extras and version specifiers within comma-separated lists; \compat.rs\ adds a compatibility layer for \pip-compile\, \pip list\, and \pip sync\ flags, issuing warnings or errors for unsupported or no-op arguments; \options.rs\ centralizes boolean flag resolution and conflict checking with source tracking (CLI, env, config); and \settings.rs\ consolidates the resolution of global and command-specific settings from CLI, environment, and configuration files. This refactoring improves maintainability and user experience by providing clearer feedback on deprecated or incompatible pip-style arguments.

crates/uv-cli/src · high confidence

Refactor resolution output into a dedicated module with requirements.txt display support

The resolution logic in \crates/uv-resolver/src/resolution\ has been reorganized into a new module structure (\mod.rs\, \display.rs\, \output.rs\, \requirements\_txt.rs\) to separate concerns. This change introduces a \DisplayResolutionGraph\ type that formats the internal resolution graph into \requirements.txt\ output, handling options for hashes, extras, markers, and annotations. It also adds a \RequirementsTxtDist\ type to manage the conversion of resolved distributions into the specific syntax required by \requirements.txt\, including support for relative paths and editable installs. The \output.rs\ module now centralizes the construction of the \ResolverOutput\ from the resolver state, managing graph creation, marker propagation, and conflict detection.

crates/uv-resolver/src/resolution · high confidence

Refactor resolver internals to support dependency groups and source-aware resolution

The resolver's PubGrub integration has been restructured to introduce first-class support for dependency groups (replacing the previous 'dev' concept) and to track source constraints on dependency edges. This change introduces \PubGrubDependency\ and \DependencySource\ to preserve direct URL and explicit index information on individual dependency edges, enabling more accurate fork construction and conflict handling. Additionally, \PubGrubPackage\ is now wrapped in an \Arc\ for efficient cloning, and the package model distinguishes between base packages, extras, groups, and markers via \PackageNodeKind\, allowing the resolver to correctly handle conflicting groups and proxy packages.

crates/uv-resolver/src/pubgrub · high confidence

Refactored Python interpreter and environment management into dedicated modules

The \uv-python-interpreter\ crate has been restructured to separate concerns, introducing new modules for environment handling (\environment.rs\), interpreter querying (\interpreter.rs\), virtual environment parsing (\virtualenv.rs\), and requested interpreter tracking (\requested.rs\). This change introduces the \RequestedInterpreter\ type to retain the original Python selection request alongside the resolved interpreter, ensuring that environment creation respects constraints from version files and project metadata. It also adds specific error types like \EnvironmentNotFound\ and \InvalidEnvironment\ to provide clearer diagnostics when Python environments cannot be located or are malformed, and updates the \pyvenv.cfg\ parsing logic to use the \astral-ini\ library for more robust configuration reading.

crates/uv-python-interpreter/src · high confidence

Refactored Python type definitions into a dedicated module

The \crates/uv-python-types\ crate has been restructured to provide a cleaner, more modular API for Python versioning and discovery. This change introduces dedicated types for Python architectures, implementation names (including Pyodide, GraalPy, and PyPy), and installation keys, alongside robust request parsing for managed Python downloads. Users benefit from more precise control over Python environment selection, including explicit support for platform-specific requirements (OS, architecture, libc) and configurable download mirrors for different Python implementations.

crates/uv-python-types/src · high confidence

Refactored managed Python installation logic into dedicated modules

The managed Python installation logic has been reorganized into separate modules (\downloads\, \managed\, \macos\_dylib\, \sysconfig\, and \windows\_registry\) to improve code structure and maintainability. This change introduces specific capabilities such as atomic sysconfig updates, improved error handling for download requests, and better integration with Windows registry (PEP 514) and macOS dynamic library patching. Users benefit from more robust error messages and clearer separation of concerns in how managed Python versions are discovered, downloaded, and installed.

crates/uv-python-managed/src · high confidence

Refactored metadata parsing into a dedicated module with PEP 794 support

The metadata parsing logic has been reorganized into a new \crates/uv-pypi-types/src/metadata\ module, introducing specialized structs for different metadata sources: \ResolutionMetadata\ for dependency resolution, \RequiresDist\ for extracting requirements without version info, \Metadata23\ for full Core Metadata 2.x parsing, and \Metadata10\ for minimal PKG-INFO parsing. This change adds support for PEP 794 (Core Metadata 2.5) by including \import\_names\ and \import\_namespaces\ fields in \Metadata23\, along with validation to prevent overlap between them. It also introduces \BuildRequires\ to model \build-system.requires\ from \pyproject.toml\ and refactors \PyProjectToml\ parsing to handle dynamic fields more precisely, ensuring that dynamic \requires-python\ or dependencies are correctly rejected when static values are required.

crates/uv-pypi-types/src/metadata · high confidence

Separate console and GUI entry points for uv-trampoline on Windows

The uv-trampoline binary now provides distinct entry points for console and GUI modes on Windows. A new console binary (uv-trampoline-console.rs) launches with a console window and calls the bounce function with a false flag, while a new GUI binary (uv-trampoline-gui.rs) launches without a console window and calls the bounce function with a true flag. This allows users to choose whether the trampoline process displays a console window or runs silently in the background.

crates/uv-trampoline/src/bin · high confidence

Structured platform tag parsing and free-threaded ABI support

The \uv-platform-tags\ crate has been refactored to use structured types for parsing and formatting wheel tags, replacing previous string-based handling. This introduces explicit \LanguageTag\, \AbiTag\, and \PlatformTag\ enums that support a wider range of platforms (including iOS, Android, Pyodide, and PyEmscripten) and implementations (GraalPy, Pyston). Crucially, it adds support for PEP 703 free-threaded Python (3.13+) by recognizing \abi3t\ tags and validating ABI compatibility for freethreading and debug builds, ensuring correct wheel selection for these new Python configurations.

crates/uv-platform-tags/src · high confidence

Structured warning output with cause chains and deduplication

The \uv-warnings\ crate now provides structured warning rendering that displays error cause chains and optional hints, similar to error reporting. Users will see warnings formatted with yellow styling, including nested causes and actionable hints when available. The system also deduplicates warnings based on their full rendered content, ensuring that repeated identical warnings (including their cause chains and hints) are only printed once.

crates/uv-warnings/src · high confidence

Updated virtual environment activation scripts

The virtual environment activation scripts (bash, fish, csh, PowerShell, batch, Nushell, and Xonsh) have been updated to the latest versions from the upstream virtualenv project. This brings improvements to shell compatibility, fixes path discovery in relocatable environments, and ensures correct handling of environment variables like VIRTUAL\_ENV\_PROMPT and code pages on Windows.

crates/uv-virtualenv/src/activator · high confidence

Validate .dist-info directory stems against package names

The uv-metadata crate now validates that the .dist-info directory name starts with the normalized package name, matching pip's behavior. This prevents erroneous version warnings and ensures metadata is read from the correct directory, even when wheel names contain non-standard characters or casing.

crates/uv-metadata/src · high confidence

Windows trampoline binaries are now byte-for-byte reproducible

A new post-build normalization tool has been added to zero out non-deterministic fields in PE executables, specifically the COFF header timestamp, debug directory timestamps, and CodeView PDB70 GUIDs. This ensures that Windows trampoline binaries built with the same source code produce identical output, eliminating variations caused by build timestamps and debug identifiers.

crates/uv-trampoline-builder/src/bin · high confidence

Windows trampoline launchers now embed Python path and script data in PE resources

The \uv-trampoline-builder\ crate now constructs Windows launcher executables by embedding the target Python interpreter path and optional script data directly into the executable's PE resources (specifically \UV\_TRAMPOLINE\_KIND\, \UV\_PYTHON\_PATH\, and \UV\_SCRIPT\_DATA\) using the \editpe\ library. This allows the launchers to dynamically locate the correct Python binary and execute associated script data without relying on external configuration files or command-line arguments at runtime. The change includes comprehensive tests to verify that these resource modifications match native Windows resource update behavior and preserve the PE file structure.

crates/uv-trampoline-builder/src · high confidence

Windows trampoline now uses embedded Python path and supports script/proxy modes

The Windows trampoline executables (uv.exe, uvw.exe, uvx.exe) have been updated to load the Python executable path and execution mode (script vs. proxy) from embedded binary resources rather than relying on environment variables or hardcoded paths. This allows the trampolines to correctly locate Python even when using relative paths or when invoked from different working directories, and ensures proper virtual environment detection via the \_\_PYVENV\LAUNCHER\\_ variable. Error and warning messages are now written to stderr or displayed via a message box if stderr is unavailable, improving diagnostic visibility during execution failures.

crates/uv-trampoline/src · high confidence

Test coverage

Add macOS Python installation and dylib patching benchmarks; Added ecosystem test fixtures for popular Python projects; Added independent Python implementation and test vectors for directory hashing; Added integration tests for \uv lock\ behavior; Added integration tests for \uv pip install\ JSON output and direct URL hash validation; Added integration tests for lock conflict resolution and relative exclude-newer handling; Added integration tests for the \uv tool\ command suite; Added integration tests for uv-client HTTP caching, proxying, and SSL/TLS; Added test fixture for native extension testing; Added test fixture for uv build backend; Added test fixtures for local packages and workspaces; Added test package for executable file handling; Added test support files for fake uv package; Added tests for RegisteredOnceMap and InMemoryIndex behavior; Added tests for cache removal space accounting; Added tests for uv-keyring credential operations; Added tests for wheel variant metadata parsing and ranking; Integration test suite reorganization and expansion; Integration tests for \uv pip compile\; Integration tests for centralized project environments and frozen sync; Integration tests for workspace commands; New integration test harness for Python management commands; New integration test harness for \uv pip\ commands; New integration tests for build, audit, and cache commands; Updated ecosystem test snapshots for lockfile format changes; Updated test snapshots for requirements.txt parsing.

Dependencies

2731 commits updating dependencies (194 manifests)

A dependency / build maintenance change in (dependencies) — 2731 commits (65 fixs), 194 files: “Add parsed URL to \PubGrubPackage\ (\#3426)”; “Update Rust crate async-trait to v0.1.83 (\#7787)”; “Update Rust crate indoc to v2.0.7 (\#16562)”; and 2728 more (refs \#3426, \#7787, \#16562, \#3385, \#2785, …).

(dependencies) · high confidence · unverified

Vendored netrc parser crate

The \uv-netrc\ crate has been introduced to vendor the \rust-netrc\ parser (from \gribouille/netrc\ v0.1.2), replacing the external dependency with an internal implementation. This change includes the full parser logic in \src/netrc.rs\ and \src/lex.rs\, along with the MIT license file and documentation, ensuring that netrc file parsing is handled locally within the project.

crates/uv-netrc · 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 68 → 65 (-2.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 63 → 57 (-5.8)
  • Architecture 96 → 96 (+0.0)
  • Maturity 65 → 66 (+1.0)
  • Readiness 64 → 64 (-0.5)
  • Security 81 → 80 (-1.0)
  • Domain Modelling 100 → 100 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 94 → 94 (+0.0)

Resolved (199)

  • Change coupling: download.rs ↔ mod.rs (crates/uv-distribution/src/download.rs)
  • Change coupling: extras.rs ↔ mod.rs (crates/uv-requirements/src/extras.rs)
  • Change coupling: sync.rs ↔ uninstall.rs (crates/uv-pip-commands/src/sync.rs)
  • DistributionDatabase::get_wheel (cyclomatic 16) (crates/uv-distribution/src/distribution_database.rs)
  • DistributionDatabase::stream_wheel (cyclomatic 16) (crates/uv-distribution/src/distribution_database.rs)
  • Duplicated block (10 lines × 2) (crates/uv/src/lib.rs)
  • Duplicated block (10 lines × 3) (crates/uv-distribution/src/distribution_database.rs)
  • Duplicated block (10 lines × 4) (crates/uv-lock/src/lock/mod.rs)
  • Duplicated block (10 lines × 4) (crates/uv-tool/src/tool.rs)
  • Duplicated block (10 lines × 4) (crates/uv/src/lib.rs)
  • Duplicated block (10 lines × 5) (crates/uv/src/lib.rs)
  • Duplicated block (10–20 lines × 3) (crates/uv-cli/src/settings.rs)
  • Duplicated block (11 lines × 2) (crates/uv-build-backend/src/metadata.rs)
  • Duplicated block (11 lines × 2) (crates/uv-cache/src/cli.rs)
  • Duplicated block (11 lines × 2) (crates/uv-distribution/src/diagnostics.rs)
  • Duplicated block (11 lines × 2) (crates/uv-keyring/src/macos.rs)
  • Duplicated block (11 lines × 2) (crates/uv-requirements/src/unnamed.rs)
  • Duplicated block (11 lines × 2) (crates/uv-resolver/src/resolver/mod.rs)
  • Duplicated block (11 lines × 3) (crates/uv-distribution/src/distribution_database.rs)
  • Duplicated block (11 lines × 3) (crates/uv-distribution/src/source/mod.rs)
  • …and 179 more

New (444)

  • Change coupling: latest.rs ↔ provider.rs (crates/uv-resolve-operations/src/latest.rs)
  • ClassTooLong: PipOptions (crates/uv-settings/src/settings.rs)
  • Duplicated block (10 lines × 2) (crates/uv-project-edit/src/lib.rs)
  • Duplicated block (10 lines × 2) (crates/uv-resolver/src/resolution/output.rs)
  • Duplicated block (10 lines × 2) (crates/uv/src/lib.rs)
  • Duplicated block (10 lines × 3) (crates/uv-distribution/src/distribution_database.rs)
  • Duplicated block (10 lines × 4) (crates/uv-lock/src/lock/mod.rs)
  • Duplicated block (10 lines × 4) (crates/uv/src/lib.rs)
  • Duplicated block (10 lines × 6) (crates/uv/src/lib.rs)
  • Duplicated block (11 lines × 2) (crates/uv-distribution/src/diagnostics.rs)
  • Duplicated block (11 lines × 2) (crates/uv-distribution/src/distribution_database.rs)
  • Duplicated block (11 lines × 2) (crates/uv-keyring/src/macos.rs)
  • Duplicated block (11 lines × 2) (crates/uv-python-commands/src/install.rs)
  • Duplicated block (11 lines × 2) (crates/uv-requirements/src/unnamed.rs)
  • Duplicated block (11 lines × 2) (crates/uv-resolver/src/resolver/mod.rs)
  • Duplicated block (11 lines × 3) (crates/uv-test/src/pypi_proxy.rs)
  • Duplicated block (11 lines × 4) (crates/uv-distribution/src/source/mod.rs)
  • Duplicated block (11 lines × 4) (crates/uv-project-edit/src/lib.rs)
  • Duplicated block (11 lines × 8) (crates/uv/src/lib.rs)
  • Duplicated block (11–12 lines × 4) (crates/uv/src/lib.rs)
  • …and 424 more

Changes since last survey

  • 142 commits — 136 feature/other, 6 fixes

By area

  • (root) — 37 commits
  • .github/workflows — 37 commits
  • crates/uv — 25 commits
  • crates/uv-distribution — 8 commits
  • docs/guides — 4 commits
  • crates/uv-python-interpreter — 3 commits
  • crates/uv-python-managed — 3 commits
  • crates/uv-resolver — 3 commits
  • crates/uv-dispatch — 2 commits
  • crates/uv-test — 2 commits
  • .config/nextest.toml — 1 commit
  • .github/actions — 1 commit
  • .github/cargo-cooldowns.toml — 1 commit
  • .github/renovate.json5 — 1 commit
  • agents/prompts — 1 commit
  • agents/references — 1 commit
  • crates/uv-audit — 1 commit
  • crates/uv-cli — 1 commit
  • crates/uv-client — 1 commit
  • crates/uv-dev — 1 commit

Notable commits

  • fix: Fix io-bound Windows CI nextest grouping (#22939)
  • fix: Fix uv audit project status lookups for redacted query values (#23129)
  • fix: Fix uvx on CPython builds with local versions (#23013)
  • fix: Fix macOS CPU detection on GraalPy (#23089)
  • fix: Revert workaround for Depot runner buggy git version (#23134)
  • fix: fix: preserve apostrophes in Windows activation paths (#23152)
  • change: Add BurntSushi to code quality review allowlist (#23237)
  • change: Add PackseServer::from_toml convenience constructor (#23021)
  • change: Add a vendored TPU wheel variant provider (#23066)
  • change: Add an HTTP/2 keep-alive preview feature (#23236)
  • change: Add hints when uv init finds pyproject.toml without a project table (#22916)
  • change: Add missing bracket in cache-keys inline code example (#22984)
  • change: Add preview support for consuming PEP 832 redirect files (#21822)
  • change: Adjust the cargo vet job structure (#23080)
  • change: Allow an empty inline sources table in uv remove (#23012)
  • change: Allow requesting a workspace metadata schema version (#22958)
  • change: Avoid building duplicate cached tool environments (#23123)
  • change: Avoid multipart uploads for release artifacts (#23228)
  • change: Avoid running the same generators twice in CI (#23200)
  • change: Be more consistent in musl interpreter discovery errors (#23213)
  • …and 122 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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

About this page

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