Homebrew/legacy-homebrewArchived

Features

• Binary Package Managers - Functions as a binary package manager that distributes pre-compiled software bundles to accelerate installation across platforms.
• CLI Software Installers - Provides a command-line interface for the installation, updating, and removal of software across multiple operating systems.
• Command Line Package Managers - Implements a complete command line package manager for installing and updating software across different operating systems.
• Package Installers - Provides the core utility for downloading and installing software packages and their dependencies from source or binary.
• System Package Manager Installations - Functions as a system package manager for installing third-party software not available in official OS distributions.
• Application Installers - Provides a mechanism for automating the download and installation of applications via declarative recipe scripts.
• Binary Distribution Platforms - Operates as a binary distribution platform that compiles source code and distributes pre-compiled binaries.
• Binary Distribution Systems - Distributes pre-compiled binaries in portable archives to accelerate the software installation process.
• Build Configuration Arguments - Applies standardized compilation flags across various build systems to ensure consistent software installation standards.
• Build System Configurations - Overrides executable paths and installation directories for build tools to customize the compilation process.
• Compiler Toolchain Validation - Identifies and prevents the use of incompatible compiler versions to maintain a working build toolchain.
• Download Strategies - Defines diverse retrieval methods for fetching source code from version control systems or archives.
• Executable Script Installation - Manages binary placement, file renaming, and script shebang modifications for correct interpreter execution.
• Installed Package Management - Provides utilities to track, list, and filter software currently installed on the system.
• Isolated Environment Managers - Creates virtual environments and dedicated directories for language-specific packages to prevent dependency conflicts.
• Package Definitions - Uses declarative specifications to define software sources, versions, and integrity checksums for automated installation.
• Package Dependency Managers - Declares the OS versions, hardware architectures, and software prerequisites required prior to installation.
• Repository Extensions - Adds or removes external Git repositories containing additional formulae to expand the available software library.
• Package Uninstallers - Provides utilities to uninstall software and perform deep cleanup of associated preference files and caches.
• Package Upgraders - Updates outdated, unpinned packages to their latest available versions.
• Build Recipes - Uses declarative scripts to define source URLs, checksums, and build instructions for automation.
• Versioned Component Installations - Provides the ability to install specific software versions using fully qualified identifiers to avoid naming conflicts.
• Binary Distribution Tools - Provides utilities for packaging and distributing pre-compiled application binaries across multiple operating systems.
• Dependency Management - Resolves software requirements and manages isolated environments for language-specific libraries.
• Binary and Source Installation - Determines whether to install a pre-compiled binary or build from source based on the system architecture.
• Prebuilt Binary Installations - Downloads and installs pre-compiled binary packages when they match the current system architecture.
• Build Artifact Deployment - Moves binaries, bundles, and plugins into specific system directories during the installation process.
• Custom Installation Sources - Supports installing software by referencing remote repositories or tapping custom sources.
• Upstream Version Automation - Monitors upstream software releases and automatically updates installation recipes through automated pull requests.
• Package Metadata - Defines identity, versioning, and build instructions required to compile and install software packages.
• Metadata Validations - Consumes signed JSON metadata to verify correctness and mitigate local code execution risks.
• Distribution Package Generators - Automates the creation of installation scripts (formulae) for packages using external tooling.
• Repository Management - Administrates the collection of external package repositories, including adding, removing, and listing sources.
• Custom Repository Registration - Adds external Git repositories as sources to enable tracking and installation of custom software.
• Software Packaging - Creates template-based recipe files to automate the installation of software across different platforms.
• Automated Recipe Updates - Forks, commits, and pushes version updates for installation recipes via automated workflows.
• Architecture-Aware Pathing - Dynamically resolves download URLs and installation paths based on the detected hardware architecture.
• File Integrity Verifications - Validates downloaded archives against cryptographic hashes to prevent corrupted or malicious installations.
• Multi-Architecture Support - Customizes download URLs and software versions based on the detected hardware architecture of the system.
• Dependency Specifications - Defines the specific software, OS versions, and hardware requirements necessary to build or run a package.
• Download Integrity Verification - Matches downloaded files against explicit checksums in reviewed metadata to prevent compromised installations.
• Package Integrity Verifications - Validates the authenticity of packages using cryptographic checksums to block corrupted files.
• Provenance Verification - Uses digital attestations to confirm the identity and environment that produced a binary package.
• Environment Variable Managers - Manages and filters environment variables during build and test phases to control compilation behavior.
• Reproducible Build Environments - Ensures software binaries are generated identically regardless of the host machine by using isolated build environments.
• Software Repository Administration - Manages remote software sources and Git repositories that host package definitions and installation scripts.
• Cross-Architecture Build Testing - Runs full lifecycle tests across various hardware architectures to verify changes before merging.
• Environment State Restoration - Installs, upgrades, or verifies a set of packages based on a declarative list from a configuration file.
• User-Level Installers - Installs language modules into user-controlled directories to bypass the need for superuser privileges.
• Build Environment Shells - Provides an interactive shell within the specialized environment used for building packages to assist troubleshooting.
• Compiler Installation Utilities - Installs specific compiler versions to enable building software for various hardware architectures.
• Cross-Platform Package Managers - Implements a unified package management interface that works consistently across different operating systems.
• Platform-Specific Restrictions - Restricts package availability based on the detected operating system, hardware architecture, or OS version.
• Package Search - Provides utilities for querying and discovering available software packages via names and descriptions.
• Package Metadata Querying - Fetches detailed package information and metadata in human-readable or machine-parseable JSON formats.
• Binary Compatibility Tracking - Tracks version compatibility between packages to avoid unnecessary rebuilds of dependent software.
• Syntax and Type Verification - Checks files for type correctness and syntax errors using configurable strictness levels to ensure stability.
• Runtime Overrides - Directs the system to use specific runtime installations instead of defaults by configuring environment variables.
• Environment Variable Synchronizers - Generates shell export statements to synchronize binaries and directories across system paths.
• In-Place File Mutators - Modifies specific strings within files during installation to adapt software to specific system hierarchies.
• Post-Installation Extensions - Runs initialization commands and sets up system services after the primary installation completes.
• Installed Software Snapshotting - Records all currently installed packages and configurations into a single file for backups or replication.
• Local Package Repositories - Clones full package catalogs locally to avoid dependency on remote APIs during installation.
• Package Customizations - Enables the tailoring of package definitions to customize build configurations and dependencies.
• Definition Auditing - Checks package definitions for coding style violations and eligibility before submission.
• Dependency Visualization - Displays required and missing dependencies for packages as a list, tree, or graph.
• Dependency Update Cooldowns - Implements download cooldowns for specific ecosystems to allow the community to detect malicious releases.
• Requirement Resolution - Identifies all required dependencies for a specific package to understand full installation needs.
• Legacy Distribution Support - Enables the installation of current software versions on older host distributions that provide outdated system packages.
• Package Linking Tools - Manages the visibility and linking of installed packages within the system path to control isolation.
• Ephemeral Dependency Execution - Installs required packages and runs commands with those dependencies automatically added to the system path.
• Version Pinning - Prevents specific packages from being automatically upgraded to ensure system stability.
• Automated Update Pull Requests - Monitors packages for new releases and automatically opens pull requests to keep software current.
• Python Environment Managers - Manages Python versions and isolated virtual environments to prevent system-wide dependency conflicts.
• Isolated Library Linking - Installs libraries into isolated directories and links them to the system path to prevent linking conflicts.
• Shell Execution Environments - Executes processes within a shell environment where paths and variables are tailored to specific package requirements.
• Custom Repository Creation - Sets up Git repositories with the required directory structure to host and distribute custom software.
• Software Update Checkers - Scans upstream repositories and APIs to identify the latest available software versions.
• System Dependency Managers - Tracks and verifies installed versions of system build tools to ensure environment compatibility.
• Development Branch Tracking - Provides an alternate download path for the latest development branches of projects.
• Version Freezing - Prevents specific installed packages from being updated during general upgrade processes.
• Version Pinning - Prevents specific packages from being updated automatically to ensure system stability.
• Build Determinism Tools - Sets build environment dates to source modification times to produce bit-identical, reproducible binaries.
• Binary Publication Workflows - Triggers the automated build and publication of binary packages for specific software requests.
• Build Environment Isolation - Filters environment variables and restricts filesystem access during builds to prevent secret exfiltration.
• External Dependency Managers - Verifies the presence of non-native external tools and binaries required before starting the build process.
• Binary Package Generators - Compiles source code into distributable binary files and generates required package metadata.
• Package Deprecation - Provides a phased removal process by marking packages as deprecated to warn users before blocking installation.
• Formula Patching - Allows the modification of installation recipes to fix build errors or remove obsolete configuration options.
• Unattended Installation Routines - Executes the installation process without interactive prompts or password requests for automation scripts.
• Environment State Export - Exports installed packages to a file to enable environment recreation in a new location.
• Remote Binary Uploaders - Pushes pre-compiled binary packages to remote repositories to ensure fast and consistent installations.
• Remote Version Monitors - Detects new software releases using custom logic when automated version detection is unavailable.
• Remote Script Distribution - Hosts external command scripts in remote repositories for installation and execution by users.
• Upstream Version Trackers - Monitors external software registries to automatically trigger version updates in build recipes via pull requests.
• Virtual Environment Isolation - Creates isolated virtual environments for Python applications to prevent system contamination.
• Python Version Managers - Installs current and maintained releases of Python 3 and corresponding executables.
• Repository Trust Restrictions - Requires explicit user trust to load non-official repositories to prevent execution of untrusted code.
• AI Assisted Code Auditing - Analyzes package contributions using AI assistants to perform style checks, type checking, and test execution.
• Conflict Declarations - Prevents two incompatible packages from being installed simultaneously when they ship conflicting binaries.
• Binary Path Relocation - Provides the ability to rewrite hardcoded paths within binaries to ensure software works in non-default installation directories.
• Source-Level Patch Integration - Applies diff files to modify source code during the build process to fix errors or add features.
• Library Compatibility Managers - Prevents installation if a dependency was built with an incompatible standard library to avoid runtime errors.
• Package Detail Retrievers - Provides a JSON interface for retrieving package metadata without requiring local installation.
• Reproducible Builds - Enforces consistent compilation flags and fixed timestamps to ensure identical binaries across build machines.
• Reproducible Archiving - Creates gzip archives that exclude variable timestamps to ensure identical output across different build machines.
• Software Lifecycle Management - Manages the full lifecycle of software, from installation and warnings for deprecation to final removal.
• Installation Lifecycle Hooks - Executes custom scripts before and after installation or uninstallation to prepare the system.
• Background Service Managers - Manages the lifecycle of background services, including starting, stopping, and restarting tasks via native service managers.
• Desktop Health Scans - Scans the system for configuration errors and missing dependencies to ensure a healthy installation environment.
• Declarative Package Updaters - Updates software versions in central repositories by modifying download URLs and checksums via pull requests.
• Tap Repository Management - Extends the software library by cloning and tracking external Git repositories for package definitions.
• Pull Request - Tracks automated build statuses to provide pass/fail indicators on pull requests.
• Static Analysis - Executes automated linting, type-checking, and security scanning on package definitions.
• Isolated Functionality Testing - Runs automated test blocks to verify basic application behavior in a temporary environment.

Star history