Homebrew/homebrew-core

Features

• Cross-Platform Package Managers - Provides a unified package management interface for installing and updating software across macOS and Linux.
• Package Installers - Provides core utilities for installing software packages on macOS and Linux, often providing newer versions than the native OS.
• Centralized macOS Package Management - Functions as a centralized system for installing, updating, and managing software dependencies on macOS.
• Package Dependency Resolution - Calculates a tree of required software components to ensure all dependencies are installed before a target package.
• Binary Distribution Systems - Implements a system for distributing pre-compiled binary archives to optimize installation speed.
• Binary Distributions - Distributes pre-compiled software packages as binaries to eliminate the need for local compilation.
• Build Isolation Tools - Runs builds and tests in a sandbox that restricts filesystem and network access.
• Package Search - Performs substring or regular expression searches across package names and descriptions to find software.
• Git-Based Package Managers - Uses Git repositories as the primary distribution mechanism for synchronizing versioned package definitions.
• External Formula Repository Integration - Integrates external Git-compatible repositories to expand the collection of available software formulae.
• Formula Definitions - Generates formula or cask files to define how specific software should be installed and managed.
• Package Definitions - Provides a declarative schema for defining software installation steps, sources, and integrity checks via formulae and casks.
• Package Dependency Managers - Provides the primary mechanism for defining and resolving software and system dependencies required for installation.
• Automated Formula Updates - Automates the process of monitoring upstream releases and submitting pull requests to update package formulae.
• Upstream Metadata Synchronization - Submits updated version metadata and installation instructions via pull requests to keep software definitions current.
• Update Detection - Identifies the newest version of a package by querying upstream sources like Git repositories or websites.
• Package Upgraders - Updates outdated, unpinned packages to their latest versions using the original installation options.
• Pre-compiled Package Binaries - Distributes architecture-specific binary bottles to allow installation without requiring local compilation from source.
• Ruby Package Definitions - Defines installation recipes and dependency specifications for macOS and Linux software using a Ruby-based DSL.
• Package Manager Upgrades - Syncs package definitions and upgrades installed software to the latest available versions.
• Binary Publication Workflows - Provides workflows to trigger the build and publication of binary packages for specific pull requests.
• Dependency Resolvers - Calculates and installs the required libraries and components needed for target software to function.
• Prebuilt Binary Installations - Automatically downloads and installs pre-compiled binary packages when a compatible bottle exists for the system architecture.
• Distributed Version Control Architectures - Utilizes a distributed version control architecture to synchronize package definitions across a global network of users.
• Binary Package Regeneration - Initiates workflows to rebuild and refresh existing binary bottles to keep them current with source updates.
• Binary Package Generators - Generates pre-compiled binary packages (bottles) from source formulae for efficient distribution.
• Upstream Version Automation - Automatically tracks external software releases to trigger updates in package build recipes via pull requests.
• Package Provisioning - Enables automated installation and management of software packages based on declarative manifest files.
• Software Packaging Standards - Implements a standardized schema for defining how software should be installed and distributed.
• Linux Package Management - Provides a consistent toolset for managing software installations and dependencies across various Linux distributions.
• Software Dependency Resolution - Calculates and installs the tree of required libraries and system components needed for software to run.
• Software Path Isolation - Controls whether packages are linked into the default system path or isolated from other software.
• System Path Symlinking - Provides a mechanism to link installed binaries into the system prefix for command-line accessibility.
• Domain Specific Languages - Employs a Ruby-based domain specific language to define precise installation and build recipes.
• Ruby-Based Package Definitions - Utilizes Ruby scripts to define the build and installation requirements for open-source software.
• Download Integrity Verification - Validates the authenticity of downloaded source archives and binary bottles using cryptographic hash checksums.
• Package Integrity Verifications - Validates the authenticity of source packages and binaries using checksums to prevent corrupted installations.
• Application Metadata Definitions - Defines versioning, checksums, and uninstall procedures in configuration-based metadata to simplify packaging.
• Build Configuration Arguments - Applies pre-defined compilation arguments for common build systems to ensure installation standards.
• Build Patching Utilities - Modifies source code or build flags during installation to resolve linker errors and ensure compatibility.
• Build Sandboxes - Executes compilation and installation steps in a restricted sandbox to prevent unauthorized filesystem or network access.
• Build-Time Source Modifications - Modifies source code files in-place using regular expressions to adapt build systems or apply patches during installation.
• Build Tool Configurations - Configures build tools with the correct executable and installation paths using standardized mechanisms.
• Source Code Retrieval Utilities - Automates the fetching of source archives and version control repositories to retrieve files for building software.
• Custom Command Distribution - Adds custom command scripts to the repository to provide users with extended functionality.
• Command-to-Package Suggestions - Analyzes failed command executions to suggest the specific package that provides the missing executable.
• Dependency Declarations - Enables reproducible installations by specifying required Python versions and module resources.
• Binary Compatibility Tracking - Tracks binary compatibility to prevent unnecessary recompilation of dependent software during updates.
• Syntax and Type Verification - Analyzes source code for type errors and signature mismatches using configurable strictness levels.
• Reproducible Compression - Implements compression that removes variable timestamps to ensure bit-for-bit reproducible binary outputs.
• Executable Script Installation - Moves compiled binaries into the system path and manages execution permissions and renaming.
• Installed Package Management - Provides utilities to track and query the list of software currently installed on the system.
• Language-Specific Package Managers - Installs specific language runtime packages through dedicated managers to ensure correct library versions.
• Installed Software Snapshotting - Records the current set of installed packages into a manifest file to enable backups and reproduction.
• Lifecycle Script Execution - Executes custom preparation and cleanup scripts immediately before or after the installation process.
• Compiler Version Fallbacks - Implements logic to select alternative compatible compilers when a specific version fails to build.
• Runtime Requirement Specifications - Specifies required Node versions or build-time tools within package definitions to ensure environment compatibility.
• Non-Interactive CLI Modes - Suppresses interactive terminal prompts and password requests to support automation scripts in headless environments.
• Automated Package Definition Generation - Automatically generates package installation recipes to accelerate the onboarding of new software.
• Definition Linting & Analysis - Runs automated linting, static analysis, and type-checking on package definitions to ensure correctness.
• Installation Verification - Audits formula syntax and runs automated tests to ensure a package installs correctly before distribution.
• Installation Script Customization - Allows modification of installation scripts and configuration arguments to customize how software is built or installed.
• Package Publishing Pipelines - Automates the creation and publication of pre-compiled binary bottles to a repository via CI workflows.
• Dependency Pruning - Automatically uninstalls orphaned dependencies that are no longer required by any installed package.
• Package Repository Configurations - Manages the addition and removal of formula repositories from Git-compatible URLs.
• Ephemeral Dependency Execution - Installs required dependencies on the fly to execute specific commands with those binaries in the system path.
• Repository Extensions - Integrates external Git repositories to expand the library of available software formulae.
• Package Uninstallers - Handles complex uninstallation by defining cleanup tasks to remove preference files and caches.
• Version Pinning - Provides the ability to pin specific packages to prevent automatic upgrades during bulk update operations.
• Pull Request Merging Tools - Automatically merges pull requests once maintainer approval and continuous integration tests are successful.
• Shell Completion Generators - Automatically generates shell-specific auto-completion scripts by executing installed binaries during the installation process.
• Shell Completions - Supplies command-line interface auto-completion definitions for the primary CLI and installed packages.
• Shell Environment Managers - Provides export statements to add installed binaries to the current shell's system PATH.
• Environment-Aware Command Executions - Executes commands or shells with environment variables and paths configured according to a package manifest.
• Package Metadata Inspectors - Provides commands to retrieve and display detailed metadata such as versions and homepages for software packages.
• Version Monitoring - Uses custom logic and regular expressions to identify the latest available versions of upstream projects.
• Versioned Component Installations - Installs specific versions of a package when multiple versions are available as distinct formulae.
• Installed Version Listing - Displays a detailed summary of installed formulae and casks with filtering for versions and sources.
• Version Pinning - Prevents a package from being updated during global upgrade processes to ensure version stability.
• Build Environment Configurations - Sets and filters environment variables during installation and testing to control compiler behavior.
• Package Deprecation - Marks packages as deprecated or disabled to warn users and prevent the installation of obsolete versions.
• Formula Testing - Verifies package functionality by executing test blocks and asserting expected outputs in temporary environments.
• Cross-Manager Dependency Synchronization - Synchronizes a collection of dependencies across multiple managers using a single declarative configuration file.
• Installation Artifact Mapping - Defines the mapping between build artifacts and their target destination folders on the host system.
• Update Exclusions - Implements rules to prevent specific software packages from being automatically upgraded.
• Architecture-Specific Routing - Selects specific build flags and binary artifact URLs based on the detected CPU architecture and operating system.
• Architecture-Specific Artifact Routing - Routes software downloads to different binary artifacts or source URLs based on the host CPU architecture and OS version.
• Python Version Managers - Enables the installation of specific versioned releases of the Python 3 interpreter.
• Execution Sandboxes - Executes a command within a restricted environment that limits write access and network connectivity.
• Build Provenance Attestors - Verifies build attestations using cryptographic tooling to ensure binaries were produced by an authorized identity.
• Package Signing - Distributes package definitions as signed JSON metadata to avoid executing untrusted code during installation.
• Provenance Verification - Checks the authenticity of binary packages using attestation tools to ensure build integrity.
• Explicit Trust Models - Requires explicit user opt-in to trust non-official repositories and manages trust for specific formulae.
• Repository Trust Verifiers - Controls whether specific packages or external repositories are trusted to be executed on the system.
• Conflict Declarations - Declares incompatible software packages that cannot coexist on the same system to prevent binary collisions.
• Binary Path Relocation - Replaces environment-specific paths in binaries with placeholders to enable installation in any host directory.
• System Configuration - Manages system-level settings and conditional dependencies to ensure software installs correctly across different operating systems.
• Background Service Configurations - Defines service files with custom commands and environment variables to manage software as background system daemons.
• Background Service Managers - Manages the lifecycle of background services by interfacing with system-native daemon managers.
• Build Dependency Managers - Provides paths and configuration flags for isolated packages to be detected by external compilers.
• Installation State Migration - Exports a manifest of currently installed packages to reproduce the exact software state in a new environment.
• System State Synchronization - Ensures local system state matches a declarative configuration by removing unmanaged packages.
• Package Lifecycle Testing - Runs automated builds and lifecycle tests on virtual machines to verify package definition changes.
• Formula Quality Checks - Runs comprehensive validation including style checks, type checks, and functional tests on package formulae.
• Style Linting - Checks formulae for adherence to house style and formatting standards using a dedicated linting command.
• Package Style Auditing - Verifies package definitions against coding style standards and provides automated fixes for conformance.

Star history