PCSX2 Documentation/Compiling on Linux: Difference between revisions

From PCSX2 Wiki
Jump to navigation Jump to search
m (Honesty in labeling.)
 
(65 intermediate revisions by 8 users not shown)
Line 1: Line 1:
NOTE: Only 32-bit architectures are supported, or distributions that allow the installation of 32-bit packages under a 64-bit architecture.
The following is a guide on how to obtain and compile the PCSX2 source code on the Linux platform.


==Introduction==
'''For a more in-depth guide on the PCSX2 build process, please don't refer to this guide here, as it is massively outdated:'''
*[[PCSX2 Documentation/PCSX2 Build Scripts]]


This is intended to give you an idea of how to compile PCSX2 from git in Linux. Some of the steps may be different on some versions of Linux, and this is not generally supported by the PCSX2 team. If you have issues following this guide, I'd recommend going through this thread for help: http://forums.pcsx2.net/Thread-Linux-Compile-Guide-and-Support
==Obtaining the Source Code==


==CMake Build System==
PCSX2 is hosted on GitHub, a website where people can contribute to each others' programming projects using the Git version control software. GitHub is essentially just a showcase for your projects, to actually work on them you need to download and install Git itself.


===Debian/Ubuntu build dependencies===
*'''Arch Linux:''' <code># pacman -S git</code>
*'''Debian:''' <code># apt-get install git</code>
*'''Fedora:''' <code># dnf install git</code>


====Build system====
Next you are going to want to create a directory on your machine for the PCSX2 code to live in. For this example, let's say the directory you create is /home/your/workspace. You are going to want clone the remote PCSX2 repository like so:
<code>gcc</code>, <code>gcc-multilib</code>, <code>g++</code>, <code>g++-multilib</code>, <code>cmake</code>


====32-bit libraries on x86_64====
<source lang="bash">
<code>libaio-dev:i386</code>, <code>libbz2-dev:i386</code>, <code>libcggl:i386</code>, <code>libegl1-mesa-dev:i386</code>, <code>libglew-dev:i386</code>, <code>libgles2-mesa-dev</code>, <code>libgtk2.0-dev:i386</code>, <code>libjpeg-dev:i386</code>, <code>libsdl1.2-dev:i386</code>, <code>libsoundtouch-dev:i386</code>, <code>libsparsehash-dev</code>, <code>libwxgtk2.8-dev:i386</code>, <code>nvidia-cg-toolkit</code>, <code>portaudio19-dev:i386</code>, <code>zlib1g-dev:i386</code>
$ cd /home/your/workspace
$ git clone git@github.com:PCSX2/pcsx2.git --recurse
</source>


===Arch Linux build dependencies===
You are now making a copy of the remote repository into your own directory.


Some of the required packages to build PCSX2 are available only in the [AUR](https://aur.archlinux.org), so the use of an [AUR helper](https://wiki.archlinux.org/index.php/AUR_Helpers) (ex: yaourt) is highly advised!
==Setting up the Build System==


====Build system====
PCSX2 uses the cmake build system to create project files and other things for multiple platforms, and GCC or clang to compile on the linux platform.
<code>gcc</code>, <code>gcc-multilib</code>, <code>cmake</code>


====32-bit libraries====
Quick compile instructions:
Add or uncomment the following lines in <code>/etc/pacman.conf</code>:


<nowiki>
{| class="wikitable"
[Multilib]
|+ Compiling a release build.
Include = /etc/pacman.d/mirrorlist</nowiki>
|-
! Compiler/build system !! command
|-
| gcc/make || mkdir build && cd build && cmake --preset=gcc-release .. && make -j <number of jobs. Say 4 or 6 if you aren't sure.>
|-
| gcc/ninja || mkdir build && cd build && cmake --preset=gcc-release-ninja .. && ninja
|-
| clang/ninja/lld || mkdir build && cd build && cmake --preset=clang-release .. && ninja
|}


Refresh package list:
And run bin/pcsx2-qt .


<nowiki>
=== Compiling ===
pacman -Sy lib32-libaio lib32-libcanberra lib32-libjpeg-turbo lib32-glew lib32-nvidia-cg-toolkit lib32-portaudio lib32-soundtouch lib32-wxgtk2.8 </nowiki>


===Using CMake===
To compile on linux, you will need git, cmake, and a compiler. For a compiler, gcc and clang are supported. If you are going to use the clang presets, also install lld as a linker. You'll also need make or ninja. Ninja is recommended, and required if using the clang presets.


====Basic mode: straightforward compilation====
====Arch====
Run the <code>build.sh</code> script.
You can view the available options with <code>build.sh -help</code>


====Expert mode: CMake build parameters====
The required packages to compile PCSX2 can be installed with:
Basic parameters:
<code># pacman -S cmake gcc</code>
*Use Release/Devel/Debug : `-DCMAKE_BUILD_TYPE=Release|Devel|Debug`
**`Release`: Best in speed, but provides little or no debug/crash info.
**`Devel`: Adds detailed trace logging abilities, but still lacks debug/crash info.
**`Debug`: No compiler optimizations. Very good for debug/crash info but also very slooowww.
*Follow XDG standard : `-DXDG_STD=TRUE`
*Build all plugins: `-DEXTRA_PLUGINS=TRUE`


Expert parameters (not supported, the best is to use the default options):
and optionally:
*Tune C flags : `-DUSER_CMAKE_C_FLAGS:STRING="cflags"`
<code># pacman -S clang lld ninja</code>
*Tune C++ flags : `-DUSER_CMAKE_CXX_FLAGS:STRING="cxxflags"`
*Tune linker flags : `-DUSER_CMAKE_LD_FLAGS:STRING="ldflags"`


Expert debugging parameters (typical developper only option):
(base-devel has gcc in it as well, and may be a good idea to install.)
*Build GS replayer: `-DBUILD_REPLAY_LOADERS=TRUE`
*Use Address Sanitizer: `-DUSE_ASAN=TRUE`
*Force wxWidget 2.8 (to spot a regression) : `-DWX28_API=TRUE`


Experimental parameters (not supported, the best is to use the default options):
====Fedora====
*zzogl: Use GLSL for shading instead of nvidia cg : `-DGLSL_API=TRUE`
*zzogl: Use EGL instead of GLX : `-DEGL_API=TRUE`
*GSdx: Use openGL ES3.1 instead of pure openGL : `-DGLES_API=TRUE`
*Use clang (nothing work) : `-DUSE_CLANG=TRUE`
*64 bits support (nothing work): `-D64BIT_BUILD_DONT_WORK=TRUE`


*Use SDL2 (wxWidget must be linked with SDL1) : `-DSL2_API=TRUE`
The required packages to compile PCSX2 can be installed with:
*Use GTK3 (wxWidget must be built with GTK3 support) : `-DGTK3_API=TRUE`
<code># sudo yum install cmake g++</code>
Expert options for package creation
*Enable package mode : follow the FHS for distribution `-DPACKAGE_MODE=TRUE`
*Plugin install path in package mode : `-DPLUGIN_DIR="/usr/lib/pcsx2"`
*GameDB install path in package mode : `-DGAMEINDEX_DIR="/usr/share/games/pcsx2"`
*GLSL shader install directory : `-DGLSL_SHADER_DIR="/usr/share/games/pcsx2"`
*Update po (translation file) : `-DCMAKE_BUILD_PO=TRUE`
*Rebuild shader : `-DREBUILD_SHADER=TRUE`
*Disable AVX: `-DDISABLE_ADVANCE_SIMD=TRUE`
*Enable/disable the stipping : `-DCMAKE_BUILD_STRIP=TRUE|FALSE`
**<code>TRUE</code>: Remove debugging information.
**<code>FALSE</code>: Keep symbols. Better for debug. (recommended since it should not have any impact on speed)


===Running CMake to generate the makefile:===
and optionally:
<code># sudo yum install ninja-build lld clang</code>


It is advised to use a build method that places build files outside the PCSX2 sources directory, as it makes it easier to delete all CMake build files:
====Ubuntu====
```
mkdir build && cd build
cmake .. <other options>
```


====Do the compilation:====
The required packages to compile PCSX2 can be installed with:
```
<code># sudo apt install cmake g++</code>
make
```


====Install files:====
and optionally:
```
<code># sudo apt install ninja-build lld clang</code>
make install  
```


===Reporting Cmake bugs===
(Like Arch, if you're having trouble, install build-essential)


Not all distributions and configurations were tested. In case you encounter a CMake bug that is really a CMake issue, you can report it. Please provide the following information:
====openSUSE====


1. Linux distribution, the current kernel version, and architecture (32-bit or 64-bit)
The required packages to compile PCSX2 can be installed with:
2. The CMake commands. For example: `cmake CMakeLists.txt`
<code>sudo zypper install cmake gcc gcc-c++</code>
3. **All** of CMake's output. Something like this is good:


```
and optionally:
-- The C compiler identification is GNU
<code># sudo zypper install ninja-build lld llvm-clang</code>
-- The CXX compiler identification is GNU
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Found GTK2_GTK: /usr/lib/libgtk-x11-2.0.so
-- Looking for XOpenDisplay in /usr/lib/libX11.so;/usr/lib/libXext.so
-- Looking for XOpenDisplay in /usr/lib/libX11.so;/usr/lib/libXext.so - found
-- Looking for gethostbyname
-- Looking for gethostbyname - found
-- Looking for connect
-- Looking for connect - found
-- Looking for remove
-- Looking for remove - found
-- Looking for shmat
-- Looking for shmat - found
-- Looking for IceConnectionNumber in ICE
-- Looking for IceConnectionNumber in ICE - found
-- Found X11: /usr/lib/libX11.so
-- Found ALSA: /usr/lib/libasound.so
-- Found BZip2: /usr/lib/libbz2.so
-- Looking for BZ2_bzCompressInit in /usr/lib/libbz2.so
-- Looking for BZ2_bzCompressInit in /usr/lib/libbz2.so - found
-- Looking for include files CMAKE_HAVE_PTHREAD_H
-- Looking for include files CMAKE_HAVE_PTHREAD_H - found
-- Looking for pthread_create in pthreads
-- Looking for pthread_create in pthreads - not found
-- Looking for pthread_create in pthread
-- Looking for pthread_create in pthread - found
-- Found Threads: TRUE
-- Found wxWidgets: TRUE
-- Found ZLIB: /usr/lib/libz.so
-- Found Cg: /usr/lib/libCg.so;/usr/lib/libCgGL.so
-- Found PortAudio: /usr/lib/libportaudio.so
-- Found SoundTouch: /usr/lib/libSoundTouch.so
-- Configuring done
-- Generating done
-- Build files have been written to: /mnt/playstation/emulateur/package/pcsx2.snapshot-4810
```


==Ubuntu PPA==
(Not absolutely sure the latter is correct. Could use testing.)


With multiarch functionality, you can install a 32-bit PPA on a 64-bit Ubuntu. You need at least Ubuntu 12.04 (Precise) to do this.
==Installing the Dependencies==


====Add the x86 architecture to your package manager (x64 installs of 12.04 or newer only)====
PCSX2 relies on a number of 3rd party software libraries, so you are going to need to obtain those before you can compile the source code. Here's a non-exhaustive list of these dependencies.</br>
In a terminal, type:
````
sudo dpkg --add-architecture i386
````


====Add the multiverse package repository====
If you don't have the following, it will use prebundled versions:
Uncomment lines looking like this, where trusty is replaced by your Ubuntu version
<source lang="bash">
````
sdl2 >= 2.0.22
deb http://us.archive.ubuntu.com/ubuntu/ trusty multiverse
fmt >= 7.1.3
deb-src http://us.archive.ubuntu.com/ubuntu/ trusty multiverse
rapidyaml >= 0.4.0
deb http://us.archive.ubuntu.com/ubuntu/ trusty-updates multiverse
zstd >= 1.4.5
deb-src http://us.archive.ubuntu.com/ubuntu/ trusty-updates multiverse
libzip >= 1.8.0
````
</source>


====Add the PCSX2 PPA to your software sources====
You have to have:
<source lang="bash">
pcap
liblzma
libaio
libsoundtouch
qt6
</source>


In a terminal, type:
If your distribution has development versions of packages, you'll probably need those packages as well. With qt 6, we're probably talking something like:</br>
```
'''Fedora:'''
sudo add-apt-repository ppa:gregory-hainaut/pcsx2.official.ppa
<source>yum install qt6-qtbase-devel qt6-qtbase-private-devel qt6-qttools-devel</source>
sudo apt-get update
```


====Install the package on your system====
'''OpenSuse:'''
<source>sudo zypper install qt6-base-devel qt6-base-private-devel qt6-tools-devel qt6-linguist-devel</source>
```
sudo apt-get install pcsx2
```


==Arch Linux==
'''Ubuntu:'''
NOTE: for 64-bit architectures, multilib must be enabled in order to install PCSX2.
<source>apt install qt6-base-dev qt6-base-private-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools</source>


===PCSX2 Stable===
(All of those worked at one point, but need to be doublechecked.)


Open a terminal, and type:
==Compiling the Source==
```
sudo pacman -S pcsx2
```


===PCSX2 Unstable===
If you didn't already get pcsx2's source, run:</br>
Add or uncomment the following lines in `/etc/pacman.conf`:
<code>$ git clone git@github.com:PCSX2/pcsx2.git --recurse</code>
```
[Multilib]
Include = /etc/pacman.d/mirrorlist
```
Refresh package list:
```
pacman -Sy
```


Download the tarball from the [AUR package page](https://aur.archlinux.org/packages/pcsx2-git), and unpack it.
Now go into the pcsx2 directory:
Open the folder that you just unpacked in a terminal, and type:
<source>$ cd ./pcsx2</source>
```
If you forgot the "--recurse" part when cloning, run this command:
makepkg -csi
<source>$ git submodule --init --recursive</source>
```
Now, make a build directory:
This will build the package, automatically installing all dependencies. It will then prompt for your password to install the package with pacman.
<source>$ mkdir -p ./build && cd ./build</source>
 
Now, it is time to compile the source code! Easiest way to do that is with a preset.<br />
 
If you're using gcc/make:
<source lang="bash">$ cmake --preset=gcc-release ..
$ make -j <number of jobs. Say 4 or 6 if you aren't sure.></source>
 
If you are using gcc & ninja:
<source lang="bash">$ cmake --preset=gcc-release-ninja ..
$ ninja</source>
 
And if you are using clang with lld and ninja:
<source lang="bash">$ cmake --preset=clang-release ..  
$ ninja</source>
 
Here's a full list, if you want a different preset:
{| class="wikitable"
|+ For reference, here is the current list of presets:
|-
! Name !! Description
|-
| ninja-multi || Generates ninja build files for debug/devel/and release builds for gcc.
|-
| gcc-debug || For making a debug build with gcc and make.
|-
| gcc-devel || For making a development build with gcc and make.
|-
| gcc-release || For making a release build with gcc and make. Does not have LTO.
|-
| gcc-debug-ninja || For making a debug build with gcc and ninja. (ninja builds faster then make.)
|-
| gcc-devel-ninja || For making a development build with gcc and ninja.(ninja builds faster then make.)
|-
| gcc-release-ninja || For making a release build with gcc and ninja. Does not have LTO. (ninja builds faster then make.)
|-
| clang-debug || For making a debug build with clang and ninja. (Fastest builds.)
|-
| clang-devel || For making a development build with clang and ninja. (Fastest builds.)
|-
| clang-release || For making a release build with clang and ninja. (This one has lto, so has the slowest build time.)
|}
 
If omit any of the libraries or headers specified above (or other, newer dependencies not included here), CMake will abort, your compiler may skip certain parts of the overall build or the linker may fail to link all the dependencies into the final PCSX2 executable. The output from any one of these tools should be able to tell the dependencies you're missing.
 
==Running the Binary==
 
This process may take several minutes. Once it has finished, you should be able to run the pcsx2 binary, which should've been output to the <code>build/bin/</code> directory.
 
<source lang="bash">$ ./bin/pcsx2-qt</source>
 
==Additional external, likely outdated links==
* [http://forums.pcsx2.net/Thread-PCSX2-for-Debian-Ubuntu PCSX2 for Debian/Ubuntu]
* [http://forums.pcsx2.net/Thread-PCSX2-for-Archlinux PCSX2 for Archlinux]
* [http://forums.pcsx2.net/Thread-PCSX2-for-Fedora PCSX2 for Fedora]
* [http://forums.pcsx2.net/Thread-PCSX2-for-Gentoo PCSX2 for Gentoo]
 
 
{{PCSX2 Documentation Navbox}}

Latest revision as of 04:33, 13 January 2023

The following is a guide on how to obtain and compile the PCSX2 source code on the Linux platform.

For a more in-depth guide on the PCSX2 build process, please don't refer to this guide here, as it is massively outdated:

Obtaining the Source Code

PCSX2 is hosted on GitHub, a website where people can contribute to each others' programming projects using the Git version control software. GitHub is essentially just a showcase for your projects, to actually work on them you need to download and install Git itself.

  • Arch Linux: # pacman -S git
  • Debian: # apt-get install git
  • Fedora: # dnf install git

Next you are going to want to create a directory on your machine for the PCSX2 code to live in. For this example, let's say the directory you create is /home/your/workspace. You are going to want clone the remote PCSX2 repository like so:

<source lang="bash"> $ cd /home/your/workspace $ git clone [email protected]:PCSX2/pcsx2.git --recurse </source>

You are now making a copy of the remote repository into your own directory.

Setting up the Build System

PCSX2 uses the cmake build system to create project files and other things for multiple platforms, and GCC or clang to compile on the linux platform.

Quick compile instructions:

Compiling a release build.
Compiler/build system command
gcc/make mkdir build && cd build && cmake --preset=gcc-release .. && make -j <number of jobs. Say 4 or 6 if you aren't sure.>
gcc/ninja mkdir build && cd build && cmake --preset=gcc-release-ninja .. && ninja
clang/ninja/lld mkdir build && cd build && cmake --preset=clang-release .. && ninja

And run bin/pcsx2-qt .

Compiling

To compile on linux, you will need git, cmake, and a compiler. For a compiler, gcc and clang are supported. If you are going to use the clang presets, also install lld as a linker. You'll also need make or ninja. Ninja is recommended, and required if using the clang presets.

Arch

The required packages to compile PCSX2 can be installed with: # pacman -S cmake gcc

and optionally: # pacman -S clang lld ninja

(base-devel has gcc in it as well, and may be a good idea to install.)

Fedora

The required packages to compile PCSX2 can be installed with: # sudo yum install cmake g++

and optionally: # sudo yum install ninja-build lld clang

Ubuntu

The required packages to compile PCSX2 can be installed with: # sudo apt install cmake g++

and optionally: # sudo apt install ninja-build lld clang

(Like Arch, if you're having trouble, install build-essential)

openSUSE

The required packages to compile PCSX2 can be installed with: sudo zypper install cmake gcc gcc-c++

and optionally: # sudo zypper install ninja-build lld llvm-clang

(Not absolutely sure the latter is correct. Could use testing.)

Installing the Dependencies

PCSX2 relies on a number of 3rd party software libraries, so you are going to need to obtain those before you can compile the source code. Here's a non-exhaustive list of these dependencies.

If you don't have the following, it will use prebundled versions: <source lang="bash"> sdl2 >= 2.0.22 fmt >= 7.1.3 rapidyaml >= 0.4.0 zstd >= 1.4.5 libzip >= 1.8.0 </source>

You have to have: <source lang="bash"> pcap liblzma libaio libsoundtouch qt6 </source>

If your distribution has development versions of packages, you'll probably need those packages as well. With qt 6, we're probably talking something like:
Fedora: <source>yum install qt6-qtbase-devel qt6-qtbase-private-devel qt6-qttools-devel</source>

OpenSuse: <source>sudo zypper install qt6-base-devel qt6-base-private-devel qt6-tools-devel qt6-linguist-devel</source>

Ubuntu: <source>apt install qt6-base-dev qt6-base-private-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools</source>

(All of those worked at one point, but need to be doublechecked.)

Compiling the Source

If you didn't already get pcsx2's source, run:
$ git clone [email protected]:PCSX2/pcsx2.git --recurse

Now go into the pcsx2 directory: <source>$ cd ./pcsx2</source> If you forgot the "--recurse" part when cloning, run this command: <source>$ git submodule --init --recursive</source> Now, make a build directory: <source>$ mkdir -p ./build && cd ./build</source>

Now, it is time to compile the source code! Easiest way to do that is with a preset.

If you're using gcc/make: <source lang="bash">$ cmake --preset=gcc-release .. $ make -j <number of jobs. Say 4 or 6 if you aren't sure.></source>

If you are using gcc & ninja: <source lang="bash">$ cmake --preset=gcc-release-ninja .. $ ninja</source>

And if you are using clang with lld and ninja: <source lang="bash">$ cmake --preset=clang-release .. $ ninja</source>

Here's a full list, if you want a different preset:

For reference, here is the current list of presets:
Name Description
ninja-multi Generates ninja build files for debug/devel/and release builds for gcc.
gcc-debug For making a debug build with gcc and make.
gcc-devel For making a development build with gcc and make.
gcc-release For making a release build with gcc and make. Does not have LTO.
gcc-debug-ninja For making a debug build with gcc and ninja. (ninja builds faster then make.)
gcc-devel-ninja For making a development build with gcc and ninja.(ninja builds faster then make.)
gcc-release-ninja For making a release build with gcc and ninja. Does not have LTO. (ninja builds faster then make.)
clang-debug For making a debug build with clang and ninja. (Fastest builds.)
clang-devel For making a development build with clang and ninja. (Fastest builds.)
clang-release For making a release build with clang and ninja. (This one has lto, so has the slowest build time.)

If omit any of the libraries or headers specified above (or other, newer dependencies not included here), CMake will abort, your compiler may skip certain parts of the overall build or the linker may fail to link all the dependencies into the final PCSX2 executable. The output from any one of these tools should be able to tell the dependencies you're missing.

Running the Binary

This process may take several minutes. Once it has finished, you should be able to run the pcsx2 binary, which should've been output to the build/bin/ directory.

<source lang="bash">$ ./bin/pcsx2-qt</source>

Additional external, likely outdated links


Retrieved from "https://wiki.pcsx2.net/index.php?title=PCSX2_Documentation/Compiling_on_Linux&oldid=107142"