MINGW-packages

Package scripts for MinGW-w64 targets to build under MSYS2.

2,241

1,207

2,241

673

View on GitHub

Top Related Projects

homebrew-core

13,575

🍻 Default formulae for the missing package manager for macOS (or Linux)

gentoo

2,057

[MIRROR] Official Gentoo ebuild repository

void-packages

2,502

The Void source packages collection

Quick Overview

MINGW-packages is a repository containing package scripts for building and distributing MinGW-w64 packages for MSYS2. It provides a comprehensive collection of packages for the MSYS2 environment, enabling users to easily build and install a wide range of software tools and libraries for Windows development using MinGW-w64.

Pros

Extensive collection of packages for Windows development
Regular updates and maintenance by a dedicated community
Simplifies the process of building and installing software for MinGW-w64
Integrates well with the MSYS2 environment

Cons

Limited to Windows development, not cross-platform
May require some familiarity with MSYS2 and package management
Some packages may have dependencies that are challenging to resolve
Building packages can be time-consuming for less powerful systems

Getting Started

To use MINGW-packages with MSYS2:

Install MSYS2 from https://www.msys2.org/
Open an MSYS2 terminal
Update the system: pacman -Syu
Install desired packages: pacman -S mingw-w64-x86_64-<package-name>

For developers who want to contribute or build packages:

Clone the repository: git clone https://github.com/msys2/MINGW-packages.git
Navigate to the package directory: cd MINGW-packages/<package-name>
Build the package: makepkg-mingw -sCLf
Install the built package: pacman -U mingw-w64-x86_64-<package-name>-<version>-any.pkg.tar.zst

Note: Replace <package-name> and <version> with the appropriate values for the package you're working with.

Competitor Comparisons

homebrew-core

13,575

🍻 Default formulae for the missing package manager for macOS (or Linux)

Pros of homebrew-core

Larger community and more extensive package collection
Better integration with macOS and native Unix-like environment
More frequent updates and active maintenance

Cons of homebrew-core

Limited to macOS and Linux, not available for Windows
Can sometimes conflict with system-installed packages
May require more disk space due to its approach of installing packages in isolated directories

Code comparison

MINGW-packages (PKGBUILD example):

pkgname=example
pkgver=1.0
pkgrel=1
pkgdesc="An example package"
arch=('any')
url="https://example.com"
license=('MIT')
source=("https://example.com/${pkgname}-${pkgver}.tar.gz")
sha256sums=('SKIP')

package() {
  cd "${srcdir}/${pkgname}-${pkgver}"
  make DESTDIR="${pkgdir}" install
}

homebrew-core (Formula example):

class Example < Formula
  desc "An example package"
  homepage "https://example.com"
  url "https://example.com/example-1.0.tar.gz"
  sha256 "SKIP"

  def install
    system "make", "install", "PREFIX=#{prefix}"
  end
end

Both repositories serve as package managers for their respective platforms, with MINGW-packages focusing on providing Windows builds of open-source software, while homebrew-core caters to macOS and Linux users. The code examples showcase the different approaches to package definitions and installation processes used by each system.

macports-ports

1,506

The MacPorts ports tree

Pros of macports-ports

Larger collection of packages, offering a wider range of software options
Better integration with macOS, providing a more native experience
Supports multiple architectures, including Apple Silicon

Cons of macports-ports

Slower package installation and update process compared to MINGW-packages
Requires more disk space due to its approach of installing packages in isolation

Code comparison

macports-ports:

PortSystem          1.0
PortGroup           python 1.0

name                py-numpy
version             1.21.2
revision            0
categories-append   science
license             BSD

MINGW-packages:

_realname=numpy
pkgbase=mingw-w64-${_realname}
pkgname=("${MINGW_PACKAGE_PREFIX}-python-${_realname}")
pkgver=1.21.2
pkgrel=1
pkgdesc="Scientific tools for Python (mingw-w64)"
arch=('any')

Both repositories use different syntaxes for package definitions, reflecting their respective package management systems. macports-ports uses TCL-based Portfiles, while MINGW-packages uses PKGBUILD files in a bash-like syntax. The macports-ports example shows a more modular approach with PortGroups, while MINGW-packages uses a more straightforward variable assignment structure.

gentoo

2,057

[MIRROR] Official Gentoo ebuild repository

Pros of gentoo

Broader scope, covering an entire Linux distribution
More comprehensive package management system
Larger community and contributor base

Cons of gentoo

Higher complexity and steeper learning curve
Requires more system resources and time for package compilation

Code comparison

MINGW-packages (PKGBUILD example):

pkgname=mingw-w64-example
pkgver=1.0
pkgrel=1
arch=('any')
depends=('mingw-w64-crt')
source=("https://example.com/${pkgname}-${pkgver}.tar.gz")

build() {
  cd "${srcdir}/${pkgname}-${pkgver}"
  ./configure --prefix=/mingw64
  make
}

gentoo (ebuild example):

EAPI=7

DESCRIPTION="Example package"
HOMEPAGE="https://example.com"
SRC_URI="https://example.com/${P}.tar.gz"

LICENSE="GPL-2"
SLOT="0"
KEYWORDS="~amd64 ~x86"

DEPEND="dev-libs/example-dep"
RDEPEND="${DEPEND}"

src_configure() {
  econf
}

Both repositories focus on package management, but gentoo covers a broader scope as it manages packages for an entire Linux distribution. MINGW-packages specifically targets the MSYS2/MinGW-w64 environment on Windows. gentoo offers more flexibility and customization options, while MINGW-packages provides a simpler approach for Windows users needing Unix-like tools and libraries.

void-packages

2,502

The Void source packages collection

Pros of void-packages

Supports a wider range of architectures, including ARM and MIPS
More comprehensive package management system with xbps
Offers a larger selection of packages, including many development tools

Cons of void-packages

Less Windows-specific optimizations compared to MINGW-packages
May require more system resources due to its broader scope
Steeper learning curve for users primarily familiar with Windows environments

Code Comparison

MINGW-packages (PKGBUILD example):

pkgname=example
pkgver=1.0
pkgrel=1
pkgdesc="An example package"
arch=('any')
url="https://example.com"
license=('MIT')
source=("$pkgname-$pkgver.tar.gz")
sha256sums=('SKIP')

package() {
  cd "$srcdir/$pkgname-$pkgver"
  make DESTDIR="$pkgdir" install
}

void-packages (template example):

pkgname=example
version=1.0
revision=1
short_desc="An example package"
homepage="https://example.com"
license="MIT"
distfiles="https://example.com/$pkgname-$version.tar.gz"
checksum=SKIP

do_install() {
  make DESTDIR=${DESTDIR} install
}

Both repositories use similar package definition formats, but void-packages uses a more streamlined template system, while MINGW-packages follows a structure closer to Arch Linux's PKGBUILD format.

nixpkgs

17,319

Nix Packages collection & NixOS

Pros of nixpkgs

Declarative and reproducible system configuration
Supports multiple platforms and architectures
Large and actively maintained package collection

Cons of nixpkgs

Steeper learning curve due to unique package management approach
Can be more resource-intensive for system builds
Less native Windows support compared to MINGW-packages

Code Comparison

nixpkgs package definition:

{ stdenv, fetchFromGitHub, cmake, boost }:

stdenv.mkDerivation rec {
  pname = "example";
  version = "1.0.0";
  src = fetchFromGitHub { ... };
  buildInputs = [ cmake boost ];
}

MINGW-packages PKGBUILD:

pkgname=mingw-w64-example
pkgver=1.0.0
source=("${pkgname}-${pkgver}.tar.gz")
depends=('mingw-w64-cmake' 'mingw-w64-boost')
build() {
  cmake -G"MSYS Makefiles" ..
}

Both repositories aim to provide package management solutions, but nixpkgs offers a more comprehensive and flexible approach for system-wide configuration. MINGW-packages focuses specifically on providing Windows builds of open-source software using the MinGW-w64 toolchain. While nixpkgs has a broader scope and supports multiple platforms, MINGW-packages excels in native Windows integration and ease of use for Windows developers.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

MINGW-packages

This repository contains package scripts for MinGW-w64 targets to build under MSYS2.

MSYS2 is an independent rewrite of MSYS providing a Unix-like environment and command-line interface for Windows making it possible to port software running on POSIX systems (such as Linux, BSD, and Unix systems) to Windows.

Documentation

See the MSYS2 website.

Using packages

The common way to use these packages are pre-built binary packages from the MSYS2 MINGW64 repo (which includes the binaries, libraries, headers, man pages), and install it on your machine, and build against those packages/libraries as you are porting/writing your software.

Details about this, including information about how to find the correct package, are found in the MSYS2 documentation.
Short summary:

Assuming you have a properly installed MSYS2 environment, you can install the pre-built binary package by using the following command from the bash prompt:

   pacman -S ${package-name}

Please note: Not all the packages in this repository are built and accessible from the MSYS2 MINGW64 repo right away. After merging changes to the git repository it can take a few days until compiled and built packages are accessible in the repo. Also for some packages you can find older versions in the repo if you need older version, for some packages you have only the most recent version.

As an alternative you can download or clone the package folder with the scripts to your machine and you build it for yourself, in whatever version you like.

Assuming you have a properly installed MSYS2 environment and build tools, you can build any package using the following command:

   cd ${package-name}
   MINGW_ARCH=mingw64 makepkg-mingw -sLf

After that you can install the freshly built package(s) with the following command:

   pacman -U ${package-name}*.pkg.tar.xz

Creating packages

See the MSYS2 documentation for instructions and advice about creating MINGW-packages.

License

MSYS2-packages is licensed under BSD 3-Clause "New" or "Revised" License. A full copy of the license is provided in LICENSE.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot