Building a MinGW WoW64 Wine with a custom vkd3d build

From WineHQ Wiki
Revision as of 10:49, 13 April 2022 by Zf (talk | contribs) (some changes)
Jump to: navigation, search

As of version 7.4, Wine comes with a bundled version of vkd3d.

However, if you want to use a more modern version of vkd3d, apply certain patches to it, or test fixes of your own, you will need Wine to work with a custom version of vkd3d.

For this purpose, it is necessary to build both projects and link them correctly.

Compiling a Windows on Windows (WoW) version of Wine, so that it supports both 32-bits and 64-bits Windows applications – which is often desired – adds a layer of complexity to the build process.

Furthermore, you may want to use MinGW to cross-compile the Wine executables and DLLs in the Windows PE format. This is because various programs expect the on-disk DLLs to look like real PE DLLs.

This guide aims to help you through that process.


Install Wine dependencies

First, install the dependencies listed in the Building Wine article.

Remember to install the :i386 version of the required packages too (if your system has multi-lib support).

The mingw and vulkan packages are of particular importance.

It is also recommended that you install ccache, as it may save us a considerable amount of time during the builds.

Tango-style info icon.svg If you have a system-wide installation of vkd3d, it may be good to uninstall it using make uninstall. To ensure that the correct version of vkd3d is linked in this tutorial.

Directory organization

For this tutorial we will need to create several build directories and have several git repositories. For this reason, we will start by creating a common directory for them:

mkdir -p $HOME/wine-dirs

Cloning wine and vkd3d repositories

First, we clone the wine repository if we haven't already:

git clone git:// $HOME/wine-dirs/wine-git

We also need to clone vkd3d repository if we haven't already:

git clone git:// $HOME/wine-dirs/vkd3d-git

In case you already have these repositories somewhere else, you can create symbolic links inside wine-dirs instead:

cd $HOME/wine-dirs
ln -s <relative-path-to-wine-repo> wine-git
ln -s <relative-path-to-vkd3d-repo> vkd3d-git

Now it is a good time to pick a particular branch or apply the desired patches to these repositories.


Build a provisional 64-bit Wine

If you already have 64-bit Wine available and built, you can skip this step.

In order to build 64-bit vkd3d we need some dependencies that can be built from the Wine repository. Namely, WIDL and the vulkan-1 DLLs.

For that purpose we need first a provisional 64-bit MinGW Wine installation, so we start by creating a folder:

cd $HOME/wine-dirs
mkdir wine64p

We run the Wine configure script from the installation folder

cd wine64p
../wine-git/configure --enable-win64 --disable-tests \
  CC='ccache gcc' CROSSCC='ccache x86_64-w64-mingw32-gcc'

Note that we use CROSSCC= to indicate the compiler used for cross-compilation, in this case we need the 64-bit mingw32 compiler. We prepend ccache which works as a wrapper for the compiler. The same is done for the regular C compiler, gcc, passed with the CC= variable.

Since this is just a provisional build of wine, we use --disable-tests to speed up the compilation times.

Note that to know about other parameters for the configure script we can use:

../wine-git/configure --help

Also, if something from the configure command fails, it is useful to search in config.log for the line that contains the pertinent error, and the lines before and after it.

Once the configure script has finished, we build Wine. We can pass -j<n> to use <n> threads.

make -j8

Build a 64-bit vkd3d installation

Now we need to do the 64-bit vkd3d build. For that purpose we will also need the Vulkan and SPIR-V headers. One way of getting them is downloading the Vulkan SDK.

Alternativelly, you can get them from the official Vulkan-Headers and SPIRV-Headers repositories.

Another alternative is to copy them from your distribution. Usually the host headers will be installed in /usr/include/vulkan/ and /usr/include/spirv/.

Assuming you downloaded and extracted the SDK, move it to the common directory:

mv <vulkan sdk path> $HOME/wine-dirs/vulkan-sdk

You must change the first argument of the mv command depending on where you downloaded and extracted the SDK. e.g. ~/Downloads/vulkansdk-linux-x86_64-

We have to run in vkd3d-git to generate vkd3d's configure script

cd $HOME/wine-dirs/vkd3d-git

Now we create a folder for the 64-bit vkd3d build

cd $HOME/wine-dirs
mkdir vkd3d64

We run the configure script in the installation folder:

cd vkd3d64
../vkd3d-git/configure \
  --host=x86_64-w64-mingw32 \
  --prefix="$HOME/wine-dirs/vkd3d64-prefix" \
  WIDL="$HOME/wine-dirs/wine64p/tools/widl/widl" \
  VULKAN_LIBS="-L$HOME/wine-dirs/wine64p/dlls/vulkan-1/" \
  CPPFLAGS="-I$HOME/wine-dirs/vulkan-sdk/x86_64/include" \
  • --host=x86_64-w64-mingw32 indicates that we want to cross-compile the programs and libraries using the 64-bit MinGW compiler.
  • --prefix="$HOME/wine-dirs/vkd3d64-prefix" is used to set this build's installation directory. In this case, we will create a new folder inside wine-dirs. We have to keep in mind that the other programs will expect the vkd3d libraries to be in this directory at run-time.
  • We set the WIDL and VULKAN_LIBS variables to point to our provisional 64-bit wine's WIDL and vulkan-1 DLL, respectively.
  • We use CPPFLAGS so that the compiler knows to search in the vulkan-sdk folder for the vulkan headers (-I flag). Note that you cannot pass -I/usr/include/ here to use the host headers; this will result in incorrect detection of headers like dlfcn.h. You will need to copy host headers to a separate directory.
  • We use LDFLAGS="-static-libgcc" because MinGW gcc depends on libgcc_s_sjlj-1.dll; this links a static version. Alternatively, you can add the correct path to --with-system-dllpath as described below.

Then we run


Append -j$(nproc) to parallelize.

And if the build succeeds, then we run

make install

to install 64-bit vkd3d in $HOME/wine-dirs/vkd3d64-prefix. If using an installation prefix inside of the home directory, there is no need to use sudo.

Build 64-bit wine

Now with the 64-bit vkd3d installation, we can compile a 64-bit Wine linked to it.

If you do not have a 64-bit wine tree already, create a new one:

cd $HOME/wine-dirs
mkdir wine64

Alternatively, you can reuse the same "provisional" Wine tree.

We run the Wine configure script again, but now specifying the parameters to link Wine to the 64-bit vkd3d prefix we just created. We will also need to include the vulkan headers:

cd wine64
../wine-git/configure --enable-win64 \
  CC='ccache gcc' CROSSCC='ccache x86_64-w64-mingw32-gcc' \
  --with-system-dllpath="$HOME/wine-dirs/vkd3d64-prefix/bin:<mingw 64-bit gcc dynamic dependencies>" \
  VKD3D_PE_CFLAGS="-I$HOME/wine-dirs/vulkan-sdk/x86_64/include -I$HOME/wine-dirs/vkd3d64-prefix/include/vkd3d" \
  VKD3D_PE_LIBS="-L$HOME/wine-dirs/vkd3d64-prefix/lib -lvkd3d -lvkd3d-shader"
  • We use --with-system-dllpath so that wine knows to search our vkd3d prefix for the vkd3d DLLs. If you did not use -static-libgcc to compile vkd3d, you should also add the libgcc path here. Depending on distribution it may be /usr/x86_64-w64-mingw32/bin/ (Arch), /usr/x86_64-w64-mingw32/sys-root/mingw/bin/ (Fedora), or /usr/lib/gcc/x86_64-w64-mingw32/##-win32/, where ## depends on the gcc version (Debian).
    • Notice that multiple paths should be separated with a colon.
  • We set VKD3D_PE_CFLAGS and VKD3D_PE_LIBS to indicate that we will use a custom version of vkd3d. We use VKD3D_PE_CFLAGS to include the vulkan headers and the vkd3d headers and VKD3D_PE_LIBS to load vkd3d's dynamic libraries.
    • Alternatively, you can install MinGW pkg-config, and pass PKG_CONFIG_PATH="$HOME/wine-dirs/vkd3d64-prefix/lib/pkgconfig".

Tango-style info icon.svg If you get the following message around the last lines:

configure: libvkd3d 64-bit MinGW development files not found; using bundled version.

Wine was not correctly linked to your custom version of vkd3d. Check the config.log.

Clean ntdll to make sure that the new system DLL path is picked up, and then rebuild wine:

make dlls/ntdll/clean

Append "-j$(nproc)" to make commands to parallelize.

Build a provisional 32-bit Wine

Now that we have a working 64-bit Wine we need to build a 32-bit Wine and link it to the 64-bit Wine in order to support 64-bit applications. For that purpose, we need to repeat the previous steps but now with a 32-bit Wine build. In essence, every instance of x86_64 should be replaced with i686.

Start by creating a provisional 32-bit Wine installation in order to compile a 32-bit vkd3d.

cd $HOME/wine-dirs
mkdir wine32p
cd wine32p
../wine-git/configure --disable-tests \
  CC='ccache gcc' CROSSCC='ccache i686-w64-mingw32-gcc'

Build a 32-bit vkd3d installation

cd $HOME/wine-dirs
mkdir vkd3d32
cd vkd3d32
../vkd3d-git/configure \
  --host=i686-w64-mingw32 \
  --prefix="$HOME/wine-dirs/vkd3d32-prefix" \
  WIDL="$HOME/wine-dirs/wine32p/tools/widl/widl" \
  VULKAN_LIBS="-L$HOME/wine-dirs/wine32p/dlls/vulkan-1/" \
  CPPFLAGS="-I$HOME/wine-dirs/vulkan-sdk/x86_64/include" \
  • We now use --host=i686-w64-mingw32 to indicate that we will use the 32-bit MinGW compiler.
  • We are changing the prefix so that this 32-bit vkd3d is installed in the vkd3d32-prefix folder instead of vkd3d64-prefix.
  • We also will link to the WIDL and vulkan-1 DLLs inside our 32-bit provisional wine.
  • We can still use the vulkan headers in our 64-bit vulkan-sdk.

We then run:

make install

Build 32-bit Wine

We can now build our 32-bit Wine, linking it to our 32-bit vkd3d.

cd $HOME/wine-dirs
mkdir wine32
cd wine32
../wine-git/configure --with-wine64=../wine64/ \
  CC='ccache gcc' CROSSCC='ccache i686-w64-mingw32-gcc' \
  --with-system-dllpath="$HOME/wine-dirs/vkd3d32-prefix/bin:<mingw 32-bit dynamic dependencies>" \
  VKD3D_PE_CFLAGS="-I$HOME/wine-dirs/vulkan-sdk/x86_64/include -I$HOME/wine-dirs/vkd3d32-prefix/include/vkd3d" \
  VKD3D_PE_LIBS="-L$HOME/wine-dirs/vkd3d32-prefix/lib -lvkd3d -lvkd3d-shader"
  • We now point --with-system-dllpath and VKD3D_PE_LIBS to the directories inside vkd3d32-prefix.

As above, clean ntdll to make sure that the new system DLL path is picked up, and then rebuild wine:

make dlls/ntdll/clean

Updating your build

If you want to update either wine or vkd3d's source code, we can execute the following commands in order. ccache should help reducing the compilations times.

# Recompile 64-bit vkd3d
cd $HOME/wine-dirs/vkd3d64;
make install

# Recompile 64-bit wine
cd $HOME/wine-dirs/wine64;

# Recompile 32-bit vkd3d
cd $HOME/wine-dirs/vkd3d32;
make install

# Recompile 32-bit wine
cd $HOME/wine-dirs/wine32;