Wine Mono is a package containing Mono and other projects, intended as a replacement for the .NET Framework (4.8 and earlier) in Wine. It works in conjunction with Wine's builtin mscoree.dll, and it is not intended to be useful for any other purpose.


SOURCE CODE

To obtain the source code, clone it from github:

$ git clone --recursive https://github.com/madewokherd/wine-mono.git

To get to the source code for a specific release, check out the appropriate tag, and update the submodules:

$ git checkout wine-mono-9.0.0
$ git submodule update --init --recursive

Source tarballs and binary packages are available at https://dl.winehq.org/wine/wine-mono/


DEPENDENCIES

To build Wine Mono, you will need the following:
 * All of the dependencies of Mono for your native (presumably Linux) system, such as autotools, CMake and a C++ compiler.
 * Wine, for the winemsibuilder and cabarc commands. A 32-bit Wine is not necessary, despite the warnings when running 64-bit Wine.
 * Python, to support the build system.
 * libgdiplus, to support Mono's resource compiler.
 * Optional: The zip or 7z command, for the tests-zip target only.

When using the Vagrant build VM, only Vagrant is required on the host machine.


BUILD

To build Wine Mono, use the msi or bin target.

$ make msi

Optionally, a build VM can be automatically set up using the Vagrantfile included with the source distribution. To start the VM, run:

$ vagrant up
$ vagrant ssh

You can then cd to /vagrant and build from there.

Note that the source code will be rsynced into the VM when it is first created. If you edit the source code on the host, you can update the VM by running:

$ vagrant rsync

Or, to have vagrant watch for changes:

$ vagrant rsync-auto


INSTALL

To install Wine Mono, run the generated msi file with msiexec:

$ wine64 msiexec /i wine-mono-9.0.0-x86.msi

Note that if a Wine Mono with a version number >= to this file is already installed, that command will do nothing, so you may have to remove the existing version (using 'wine64 uninstaller') first.

If the install succeeds, it won't output anything. You can use 'wine64 uninstaller' to verify that the version you expect is installed.

If you are building for development, you may find it more convenient to use the 'make dev' target, which builds a runtime in image/ and configures a wine prefix to use it. You can then rebuild individual dlls using their filename with no path. See 'make help' for details.

Packagers should extract the tarball from the "make bin" target to /usr/share/wine/mono or the corresponding directory for the prefix used to configure Wine. This should create a directory named something like /usr/share/wine/mono/wine-mono-9.0.0. This conserves space compared to the msi because it doesn't need to be copied into every prefix.


COMPOSITION

An installed Wine Mono contains the following:
 * Registry keys and files in C:\windows\Microsoft.NET intended to make it look as if .NET Framework is installed, so that applications won't complain that it's missing, and the installers for .NET Framework won't install. This is part of an msi package named "Wine Mono Windows Support". (Wine Mono should always be removed before installing .NET Framework 4.8 and earlier. Wine Mono can coexist with .NET Core and .NET 5 or later.)
 * A modified version of the Mono runtime and class libraries, in the "Wine Mono Runtime" msi or a shared location outside the prefix.
 * Other supporting libraries that are not part of Mono, in some cases replacing Mono's version.


BUGS

Bugs should be filed in the Wine bugzilla (http://bugs.winehq.org/) with product set to "Wine" and component set to "mscoree", or they can be filed as an issue on the wine-mono github.


PATCHES

Patches that are not for a fork should be sent as a pull request to https://github.com/madewokherd/wine-mono.

Patches to Mono should be sent as a pull request to https://github.com/madewokherd/mono.

Changes to upstream projects that make sense only within the context of wine-mono and not in any other use case should be sent as a pull request to the appropriate fork.

FNA and related projects have been very responsive to pull requests, and it's worth sending changes upstream. monoDX is similar, even though it doesn't really have a separate use case.

The mono-basic project is abandoned and PRs can be made directly to the fork. However, before doing any substantial work on mono-basic, it may be worth checking whether there's an implementation in dotnet/winforms or dotnet/runtime.

The winforms and wpf projects are not being updated from upstream, and have diverged significantly. Since they are supporting .NET Core, which adds new features and is not binary-compatible with .NET Framework, their use case is very different from ours. Any changes should be sent directly to the appropriate fork, but feel free to also send them upstream if it makes sense.