Initial commit

.github/CONTRIBUTING.md

@@ -0,0 +1,20 @@
+# Contribute to the documentation
+
+The docs are written in [Markdown](https://en.wikipedia.org/wiki/Markdown) if you need help with the syntax use [this guide](https://guides.github.com/features/mastering-markdown/). <br />
+Mkdocs uses some [Markdown extensions](http://www.mkdocs.org/user-guide/writing-your-docs/#markdown-extensions) that you may have to familiarize with.
+
+The documentation source is maintained via [Git](https://en.wikipedia.org/wiki/Git)<br />
+For novice users that don't know how to use the command line you can use [Github Desktop](https://desktop.github.com/).<br />
+For more info on how to use git [refer to their help](https://help.github.com/)
+
+In order to propose improvements to a document:
+
+1. [Clone the repo](https://github.com/libretro/docs) (If you are using [Github Desktop](https://desktop.github.com/), select Clone>Open in Desktop)
+2. Make the changes and update your clone
+3. Test, [follow the Building section to render the site](https://github.com/libretro/docs/blob/master/README.md#building)
+4. Propose your changes using the button "New Pull Request" [in the docs repo](https://github.com/libretro/docs)<br />
+make sure that you are comparing **your forks edited branch** to the **docs master branch**
+
+There is a To-Do list for libretro/docs [here](https://docs.libretro.com/meta/todo/)
+
+You can submit suggestions or issues regarding documentation at the [libretro/docs issue tracker](https://github.com/libretro/docs/issues) or in our [forum thread](https://forums.libretro.com/t/wip-adding-pages-to-documentation-site/10078/).

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,11 @@
+# First and foremost consider this:
+- Only documentation related issues should be filed here. Not RetroArch bugs, core bugs or game bugs.
+- Before reporting a 404, refresh the doc a few times.
+
+## Documents
+
+[Add a list of documents that should be changed here.]
+
+### Proposed changes
+
+[What changes should be done to the documents.]

.gitignore

@@ -0,0 +1 @@
+site/

.travis.yml

@@ -0,0 +1,8 @@
+language: python
+python:
+  - "3.6"
+install:
+  - pip install mkdocs
+  - pip install mkdocs-material
+script:
+  - ./deploy

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 libretro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,15 @@
+MKDOCS_AVAILABLE := $(shell command -v mkdocs 2> /dev/null)
+
+build: dependencies
+	@mkdocs build
+
+start: dependencies
+	@mkdocs serve
+
+install:
+	pip install mkdocs mkdocs-material
+
+dependencies:
+ifndef MKDOCS_AVAILABLE
+	$(error "mkdocs is not available. Use 'make install' to install dependencies.")
+endif

README.md

@@ -0,0 +1,43 @@
+# Libretro Documentation
+
+This is the source for the [libretro documentation](https://docs.libretro.com), powered by [MkDocs](http://www.mkdocs.org/).
+
+[MkDocs documentation](http://www.mkdocs.org/)
+
+[Material for MkDocs documentation](https://squidfunk.github.io/mkdocs-material/)
+
+[Libretro Forums topic](https://forums.libretro.com/t/wip-adding-pages-to-documentation-site/10078)
+
+[To-do list](https://docs.libretro.com/meta/todo/)
+
+![travis](https://www.travis-ci.org/libretro/docs.svg?branch=master)
+
+## Building
+
+1. Make sure you have [Python](https://www.python.org/) and [pip](https://pip.pypa.io) installed
+    ```
+    python --version
+    pip --version
+    ```
+
+2. Install MkDocs
+    ```
+    pip install mkdocs
+    ```
+
+3. Install MkDocs-Material
+    ```
+    pip install mkdocs-material
+    ```
+	
+4. Install PyMdown Extensions
+    ```
+    pip install pymdown-extensions
+    ```	
+
+5. Build the site
+    ```
+    mkdocs build
+    ```
+
+6. The documentation will be built to the `site` directory

deploy

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+git pull origin master
+mkdocs build

docs/compilation/3ds.md

@@ -0,0 +1,88 @@
+# Nintendo 3DS Compilation / Development Guide
+
+## Environment configuration
+
+You need the homebrew Nintendo 3DS SDK libctru and DevkitARM toolchain installed. 
+If you are running windows you will need to install [MSYS2](http://www.msys2.org/) and point it to your devkitARM installation like this: 
+
+    Put these lines in RetroArch3DSEnv.sh
+    export DEVKITPRO="/c/devkitPro"
+    export DEVKITARM="$DEVKITPRO/devkitARM"
+    export CTRULIB="$DEVKITPRO/libctru"
+    export CTRBANNERTOOL="/c/Users/Emily/Desktop/RetroArchDev/CompatFiles/bannertool.exe"
+    bash
+The custom bannertool is needed if you want to compile .cia builds due to a broken wav encoder in the windows version of bannertool included with RetroArch. 
+Before building RetroArch you will have to load MSYS2 and launch `RetroArch3DSEnv.sh`, then proceed as you would for linux.
+
+The working bannertool can be compiled from the sources [here](https://github.com/Steveice10/bannertool) using MSYS2.
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+First, you need to compile 'Salamander'. To compile Salamander (for 3DS) run:
+
+    make -f Makefile.ctr.salamander
+
+Second, to compile RetroArch (for 3DS) run:
+
+    make -f Makefile.ctr
+
+!!! Note
+    RetroArch on 3DS is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch 3DS. This file needs to be called 'libretro_ctr.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_ctr.elf and retroarch_ctr.dol file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory.
+
+Once inside this directory, run :
+
+    ./dist-cores.sh ctr 
+
+This process will also automate the packaging process for you.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for 3DS) is to use libretro-super. Run
+
+    ./libretro-build-ctr.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-ctr.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/ctr`.

docs/compilation/android.md

@@ -0,0 +1,86 @@
+# Compiling for Android
+
+## Compiling from Windows
+
+You need a complete Android development environment, including the **Android SDK** and **Android NDK**.
+
+**Other dependencies:**
+
+* The ant tool from [ant.apache.org](http://ant.apache.org/)
+* OpenJDK or Oracle JDK
+* Cygwin (base settings for Bash scripts)
+* Git
+
+### Installing ant
+
+Install ant in the location your prefer, then add that new bin/ PATH to the route. Remember declare %JAVA_HOME% before, or on the top of the scripts on /bin/ JDK base dir Path.
+
+### Installing OpenJDK or Oracle JDK
+
+
+### Installing cygwin
+
+Download the setup tool from the official webpage and install the base distribution.
+
+### Installing git
+
+You can install Windows git or add the cygwin git version from the cygwin installer.
+
+### Next step: From here, follow the instructions for compiling Android from Linux.
+
+## Compiling from Linux
+
+You need a complete android development environment ready to develop native apps. That means you have:
+
+* [Android SDK](http://developer.android.com/sdk/index.html)
+* [Android NDK](https://developer.android.com/tools/sdk/ndk/index.html)
+* [The ant tool](http://ant.apache.org/)
+
+Use Google to figure out how to install that and make sure the appropriate executables from the above are in your path variable.
+These instructions have been tested under Linux (Fedora 20). They may also work in windows with cygwin.
+
+### Getting the code
+
+    git clone https://github.com/libretro/libretro-super.git
+    cd libretro-super
+    ./libretro-fetch.sh  
+    
+`./libretro-fetch.sh` can fail on `fork()` calls, repeat until all are up to date. For `./libretro-build-android-mk.sh`, some cores may fail to compile (g++ "Argument list too long" error).
+
+### Building the cores
+
+    NOCLEAN=1 ./libretro-build-android-mk.sh 
+
+You can omit `NOCLEAN=1` if you'd like to perform make clean on every core's repo before building each.
+
+### Building RetroArch
+
+The RetroArch repo is fetched into the libretro-super folder by `./libretro-fetch.sh` above.
+
+You first need to fetch the submodules for it.
+
+    cd retroarch
+    git submodule update --init
+
+Then set up the android projects.
+
+    cd pkg/android/phoenix
+    android update project --path .
+    android update project --path libs/googleplay/
+    android update project --path libs/appcompat/ # this doesn't seem to exist anymore
+
+Now edit `local.properties` to point to the location of your ndk directory by adding a line like this: `ndk.dir=/complete/path/to/android-ndk-r9d`
+
+Finally, copy the cores, assets and overlays to the right place and build it.
+
+    mkdir -p assets/cores
+    mkdir assets/overlays
+    cp ../../../../dist/android/armeabi-v7a/* assets/cores/ #replace armeabi-v7a here by mips or x86 for those targets
+    cp -r ../../../../dist/info/ assets/
+    cp -r ../../../../retroarch/media/overlays/* assets/overlays/
+    ant clean
+    ant debug
+   
+If all goes well, this will spit out an .apk: `bin/retroarch-debug.apk`. Put it on your device with
+
+    adb install -r bin/retroarch-debug.apk

docs/compilation/dos.md

@@ -0,0 +1,46 @@
+# DOS Compilation / Development Guide
+
+## Environment configuration
+
+This guide will use cross-compilation from Linux to build a DOS executable with the [DJGPP](http://www.delorie.com/djgpp/) toolchain.
+
+Most Linux distributions do not include this toolchain, but prebuilt binaries can be obtained [here](https://github.com/andrewwutw/build-djgpp/releases), or if you are using Arch Linux, you can use the AUR package [djgpp-gcc](https://aur.archlinux.org/packages/djgpp-gcc/) to build it easily.
+
+DJGPP builds 32-bit programs, which means an 80386 or higher processor is required. 80286 is not supported.
+
+## Core Support
+
+!!! Note
+    RetroArch on DOS is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root of the source directory in order to link RetroArch DOS. This file needs to be called 'libretro.a'.
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+### Building RetroArch
+
+To compile RetroArch run the following commands inside RetroArch's source tree:
+
+    CROSS_COMPILE=i686-pc-msdosdjgpp- ./configure --with-libretro="-L. -lretro"
+    make clean
+    make -j4
+
+Replace the value of `CROSS_COMPILE` with the prefix of your specific toolchain if necessary.
+
+Once finished, you should find `retroarch.exe` in the current directory, this is the final binary you can run inside DOS. Since older DOS versions do not support long filenames, you may want to rename this file to something shorter.
+
+RetroArch for DOS also requires the CWSDPMI server application from the DJGPP distribution, which can be downloaded separately [here](http://www.delorie.com/pub/djgpp/current/v2misc/csdpmi7b.zip). On the target system, CWSDPMI.EXE will need to be placed in the same directory as your RetroArch executable for it to run properly.
+
+Once you have the DPMI program in place, simply run your RetroArch executable and the DPMI server will be loaded automatically at startup.
+
+It is also possible to include the DPMI server inside the main RetroArch executable so that only a single file is needed, but that is outside the scope of this document. See [here](http://www.delorie.com/djgpp/doc/utils/utils_16.html) for more information.

docs/compilation/gamecube.md

@@ -0,0 +1,72 @@
+# Nintendo GameCube Compilation / Development Guide
+
+## Environment configuration
+
+You need the homebrew Nintendo GameCube SDK libogc and Devkitpro PPC toolchain installed. 
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+First, to compile RetroArch (for GameCube) run:
+
+    make -f Makefile.griffin platform=ngc
+
+!!! Note
+    RetroArch on GameCube is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch GameCube. This file needs to be called 'libretro_ngc.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_ngc.elf and retroarch_ngc.dol file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory.
+
+Once inside this directory, run :
+
+    ./dist-cores.sh ngc 
+
+This process will also automate the packaging process for you.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for GameCube) is to use libretro-super. Run
+
+    ./libretro-build-ngc.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-ngc.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/ngc`.

docs/compilation/haiku.md

@@ -0,0 +1,70 @@
+# Haiku Compilation / Development Guide
+
+This compilation guide will teach you how to build RetroArch for Haiku. 
+
+It is more than recommended to keep your Haiku system up to date and use Nightlybuilds with upgraded packages.
+
+## Environment configuration
+
+The following software needs to be installed:
+
+- Haiku standard development packages (haiku_devel)
+- SDL libraries and development packages (libsdl_devel / libsdl2_devel)
+- X11 libraries and development packages (libx11_devel, libxau_devel, libxext_devel)
+- Mesa libraries and development packages (mesa_devel, glu_devel)
+- Jpeg, PNG, Zlib libraries and development packages (jpeg_devel, libpng16_devel, zlib_devel)
+
+Optional dependencies:
+
+- libxml2_devel - For XML shaders and cheat support.
+- freetype_devel - TTF font rendering
+- ffmpeg - FFmpeg recording
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch
+
+Make sure gcc is installed, then run:
+
+    # Build
+    ./configure --prefix=~/config/non-packaged/ --datarootdir=~/config/non-packaged/data/ --with-man_dir=~/config/non-packaged/documentation/man/ && make
+    # Install
+    make install
+    # Run
+    retroarch
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores is to use libretro-super. 
+
+To build all cores for Haiku, run
+
+    ./libretro-build.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/haiku`.

docs/compilation/ios.md

@@ -0,0 +1,176 @@
+# iOS Compilation / Development Guide
+
+## Environment configuration
+
+The following software needs to be installed:
+
+- XCode
+- iOS SDK
+
+The following versions of the operating system are supported:
+
+- iOS 6.0
+- iOS 7.0+
+- iOS 8.0+
+- iOS 9.0+
+- iOS 10.0+
+- iOS 11 support is in-progress
+
+## Get the RetroArch source
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+## Core Compilation
+
+RetroArch needs the emulation cores compiled for it to be useful. Let's compile the cores first.
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    git clone https://github.com/libretro/libretro-super
+    cd libretro-super
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for iOS) is to use libretro-super. 
+
+To build iOS 6 to 8-compatible cores, run
+
+    ./libretro-build-ios.sh
+
+To build iOS 9 and up-compatible cores, run
+
+    ./libretro-build-ios9.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-ios.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/ios` or `dist/ios9`.
+
+### Code Signing the Cores
+
+Note that you *must code sign the dylib cores* in order for you to use them.
+
+#### In iOS 9 and above
+
+Starting from iOS 9, the cores must be packaged as part of the application, even if they are code-signed. This was an additional security measure introduced in iOS 9. Fortunately, the code signing is handled as part of the Xcode build/archive process, so all you need to do is place your compiled `.dylib` cores in the `pkg/apple/iOS/modules` folder.  Running the application via Xcode or archiving the application for an adhoc distribution will codesign the cores as long as they are placed in the aforementioned `pkg/apple/iOS/modules` folder.
+
+#### In iOS 6 to 8
+
+You need to manually code sign the cores, and then you can copy them to the `Documents/RetroArch/cores` directory using an application like "iFunBox" or "iExplorer".
+
+#### Manually Code Signing
+
+```
+cd [path where the dylib cores are]
+codesign -fs '[Your Full Developer Certificate Name]' *.dylib
+```
+
+#### Known Issues with Code Signing (iOS 9 and above)
+
+Building and running from Xcode doesn't code sign the cores the first time for some reason. This is a bug in the build process. The cores seem to get signed after the cores are copied. If you build and run again, the cores will have been signed and will be usable in RetroArch.
+
+### Building RetroArch
+
+#### Using the graphical interface
+
+##### For iOS 6 to 8
+
+Open Xcode. Open the following project file `pkg/apple/RetroArch_iOS.xcodeproj` in the Xcode IDE and build (**⌘-B**) and run (**⌘-R**) it there. 
+
+##### For iOS 10 and up
+
+1. Open Xcode.
+2. Open the following project file `pkg/apple/RetroArch_iOS10.xcodeproj`
+3. In the Navigator Pane on the left, select the Retroarch_iOS10 project
+4. In the Project and Targets list on the left side, choose the RetroArchiOS10 target. Select the Target (the one with the RetroArch icon), not the project.
+5. In the "General" tab, change the "Team" under Signing to be your developer name.
+6. Set the active scheme to RetroArchiOS10, and select your connected iOS device as the device.
+6. Run (**⌘-R**)
+
+##### Creating an IPA for adhoc distribution (or for someone else to re-sign)
+
+You will need an adhoc distribution certificate to create an adhoc distribution. Go to developer.apple.com to create an adhoc certificate.
+
+In Xcode, select your target (RetroArchiOS10 for iOS 10 and above, RetroArch for others), Choose "Generic iOS Device" for the device, and select Product -> Archive. After it is done archiving, the Organizer window will appear. Select the archive and then use the "Export.." button on the right pane, and select "Save for Ad Hoc Deployment". Choose your developer name and you'll create an IPA in a directory of your choosing. This IPA can be resigned for other people to use using utilities such as [iOS App Signer](http://dantheman827.github.io/ios-app-signer/).
+
+You can install the IPA on your iOS device by dragging the IPA onto the Installed Apps section in the Devices window.
+
+##### Notes on building and running
+
+If you use Xcode to build and run RetroArch, and overwrite an existing RetroArch, you'll notice that your configuration will be wrong and stuff like your settings and directory locations will be missing. That's because you get a new application identifier when you do a re-install or upgrade, and the RetroArch config uses absolute paths in its configuration. You'll need to delete the app and then reinstall, or manually edit the RetroArch config file and fix the file paths by hand.
+
+#### Using the command line
+
+##### For iOS 6 to 8
+
+To build a debug build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Debug -project pkg/apple/RetroArch_iOS.xcodeproj
+    # Run
+    open ./pkg/apple/build/Debug/RetroArch.app/
+
+To build a release build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Release -project pkg/apple/RetroArch_iOS.xcodeproj
+    # Run
+    open ./pkg/apple/build/Release/RetroArch.app/
+
+##### For iOS 10 and up
+
+To build a debug build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Debug -project pkg/apple/RetroArch_iOS10.xcodeproj
+    # Run
+    open ./pkg/apple/build/Debug/RetroArch.app/
+
+To build a release build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Release -project pkg/apple/RetroArch_iOS10.xcodeproj
+    # Run
+    open ./pkg/apple/build/Release/RetroArch.app/
+
+### Packaging RetroArch
+
+### Additional Tips:
+
+#### Cores
+
+- When you run RetroArch and try to run a game, and see the message "Failed to load libretro core", that means the core is not code signed. See the above "Code Signing the Cores" section on making sure your cores are signed. You can manually check the code signature on a file by doing: `codesign -dvv mednafen_psx_libretro_ios.dylib`. The Authority entry has your certificate - make sure it's your dev or adhoc distribution certificate.
+
+- To see if your core is valid and usable in RetroArch, you can also try Load Core and selecting the core. If you see the core name appear at the top (in the GUI menu), then it is properly codesigned and loaded. If you still see "No Core", then your core is not codesigned and cannot be used.
+
+#### Getting your ROMs/content/BIOS in RetroArch
+
+- Use a desktop tool like "iFunBox" or "iExplorer". You can use iTunes but note that it cannot access subdirectories. BIOS files go in `RetroArch/system`
+
+- You can also download content in Safari and "Open in.." and choose RetroArch. Currently there is a bug in that it will crash (the app delegate needs fixing), but it gets placed in the "Inbox" folder in RetroArch's Documents folder. You can choose "Load Content" and navigate to the "Inbox" directory.
+
+### Development
+
+#### Where do I start?
+
+The RetroArch codebase can be daunting, especially if you're used to iOS development in Objective C or Swift. Objective C is a subset of C so the syntax should look somewhat familiar to you.
+
+The first and main entrypoint you should look at is in `core/griffin/griffin.c`. This is where all the code is included, with compiler flags used to bring in code specific to the platform. For iOS, you should pay attention to the compiler flags like `__APPLE__`, `TARGET_OS_IPHONE`, `HAVE_COCOATOUCH`.
+
+Note that you can Cmd-click into the `#include` paths to peer into the source code. You can also Cmd-Shift-O and type in the source file as well. And, breakpoints work as well!
+
+The iOS specific code is in `core/griffin/griffin_objc.m`. Here you'll find the include to `./ui/drivers/ui_cocoatouch.m`, which contains the application delegate - the main entry point for the iOS application lifecycle. From there everything should look familiar to you as an iOS developer, and you should be able to hook in any iOS specific objective c code. Although you can use Objective C data structures and code, you'll probably be having to use C data structures since you'll have to call methods in C to hook back into RetroArch, and they will expect C data structures. The great thing is you can mix C code with Objective C, as long as you do the necessary conversions to the data structures that RetroArch expects.

docs/compilation/linux-and-bsd.md

@@ -0,0 +1,60 @@
+# Compilation in Linux and BSD
+
+Compilation on Linux and BSD does not have many surprises, as its foundation is Unix-based.
+
+### Dependencies
+- At least one libretro implementation  
+- pkgconfig  
+- Working OpenGL headers (should be included by default, but you might need to install libgl/mesa development packages)
+
+### Optional dependencies
+- libxml2-devel - For XML shaders and cheat support.
+- freetype-devel - TTF font rendering
+- ffmpeg/libavcodec - FFmpeg recording
+- nvidia-cg-toolkit - Cg shaders
+- libudev-devel
+- zlib-devel
+
+Some other libraries can be built support for as well, please refer to `./configure --help`.
+
+#### Satisfying dependencies under Fedora 23
+```bash
+sudo dnf install make automake gcc gcc-c++ kernel-devel mesa-libEGL-devel libv4l-devel libxkbcommon-devel mesa-libgbm-devel Cg libCg zlib-devel freetype-devel libxml2-devel ffmpeg-devel SDL2-devel SDL-devel perl-X11-Protocol perl-Net-DBus pulseaudio-libs-devel openal-soft-devel libusb-devel
+```
+
+#### Satisfying dependencies under Debian/Ubuntu
+```bash
+apt-get -y install build-essential libxkbcommon-dev zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
+```
+
+This list of packages may not be complete.
+### Getting the code
+```bash
+git clone git://github.com/libretro/libretro-super.git
+cd libretro-super
+SHALLOW_CLONE=1 ./libretro-fetch.sh
+```
+
+### Building RetroArch
+```bash
+./retroarch-build.sh
+```
+
+### Building libretro cores
+You should at least build one libretro implementation so RetroArch can do stuff.
+There is a [super-project](https://github.com/libretro/libretro-super) that is designed to easily build every libretro port out there. To build every core:
+```bash
+NOCLEAN=1 ./libretro-build.sh
+```
+Omit NOCLEAN=1 if you wish to perform "make clean" on every repo before building 
+
+### Installing
+Let's assume you'd like to install RetroArch into a folder called `~/ra`
+```bash
+mkdir -p ~/ra/cores
+cd retroarch
+make DESTDIR=~/ra install
+cd .. #to libretro-super directory
+./libretro-install.sh ~/ra/cores
+```
+You should now have a fully functional RetroArch build in `~/ra` Enjoy! :)

docs/compilation/osx.md

@@ -0,0 +1,87 @@
+# macOS/OSX Compilation / Development Guide
+
+This compilation guide will teach you how to build RetroArch for macOS/OSX. 
+
+The following versions of the operating system are supported:
+
+- OSX 10.6    (Snow Leopard)
+- OSX 10.7    (Tiger)
+- OSX 10.8    (Mountain Lion)
+- OSX 10.9    (Mavericks)
+- OSX 10.10   (Yosemite)
+- OSX 10.11   (El Capitan)
+- macOS 10.12 (Sierra)
+
+RetroArch can work on both 32bit and 64bit Intel processor-powered Macs.
+
+## Environment configuration
+
+The following software needs to be installed:
+
+- XCode
+- (Optional) NVIDIA Cg Toolkit
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+#### Using the graphical interface
+
+Open Xcode. Open the following project file `pkg/apple/RetroArch.xcodeproj` in the Xcode IDE and build (**⌘-B**) and run (**⌘-R**) it there. Or you can use the command line....
+
+#### Using the command line
+
+To build a debug build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Debug -project pkg/apple/RetroArch.xcodeproj
+    # Run
+    open ./pkg/apple/build/Debug/RetroArch.app/
+
+To build a release build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Release -project pkg/apple/RetroArch.xcodeproj
+    # Run
+    open ./pkg/apple/build/Release/RetroArch.app/
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for iOS) is to use libretro-super. 
+
+To build all cores for OSX, run
+
+    ./libretro-build.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/osx`.

docs/compilation/osxppc.md

@@ -0,0 +1,81 @@
+# OSX PowerPC Compilation / Development Guide
+
+This compilation guide will teach you how to build RetroArch for OSX PowerPC.
+
+The following versions of the operating system are supported:
+
+- OSX 10.5    (Leopard)
+
+RetroArch can work on both 32bit and 64bit PowerPC processor-powered Macs.
+
+## Environment configuration
+
+The following software needs to be installed:
+
+- XCode
+- (Optional) NVIDIA Cg Toolkit
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+#### Using the graphical interface
+
+Open Xcode. Open the following project file `pkg/apple/RetroArch_PPC.xcodeproj` in the Xcode IDE and build (**⌘-B**) and run (**⌘-R**) it there. Or you can use the command line....
+
+#### Using the command line
+
+To build a debug build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Debug -project pkg/apple/RetroArch_PPC.xcodeproj
+    # Run
+    open ./pkg/apple/build/Debug/RetroArch.app/
+
+To build a release build :
+
+    # Build
+    xcodebuild -target RetroArch -configuration Release -project pkg/apple/RetroArch_PPC.xcodeproj
+    # Run
+    open ./pkg/apple/build/Release/RetroArch.app/
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for OSX PowerPC) is to use libretro-super. 
+
+To build all cores for OSX, run
+
+    ./libretro-build.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/osx`.

docs/compilation/psp.md

@@ -0,0 +1,76 @@
+# PlayStation PSP Compilation / Development Guide
+
+## Environment configuration
+
+You need the homebrew PlayStation PSP SDK and toolchain installed. 
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+First, you need to compile 'Salamander'. To compile Salamander (for PlayStation Portable) run:
+
+    make -f Makefile.psp1.salamander
+
+Second, to compile RetroArch (for PlayStation Portable) run:
+
+    make -f Makefile.psp1
+
+!!! Note
+    RetroArch on PlayStation PSP is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch Vita. This file needs to be called 'libretro_psp1.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_psp1.elf and retroarch_psp1.self file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory.
+
+Once inside this directory, run :
+
+    ./dist-cores.sh psp1
+
+This process will also automate the packaging process for you.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for PlayStation Portable) is to use libretro-super. Run
+
+    ./libretro-build-psp1.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-psp1.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/psp1`.

docs/compilation/psvita.md

@@ -0,0 +1,76 @@
+# PlayStation Vita/TV Compilation / Development Guide
+
+## Environment configuration
+
+You need the homebrew PlayStation Vita SDK and toolchain installed. 
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+First, you need to compile 'Salamander'. To compile Salamander (for PlayStation3) run:
+
+    make -f Makefile.vita.salamander
+
+Second, to compile RetroArch (for PlayStation3) run:
+
+    make -f Makefile.griffin platform=vita
+
+!!! Note
+    RetroArch on PlayStation Vita/TV is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch Vita. This file needs to be called 'libretro_vita.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_vita.elf and retroarch_vita.self file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory.
+
+Once inside this directory, run :
+
+    ./dist-cores.sh vita
+
+This process will also automate the packaging process for you.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for PlayStation3) is to use libretro-super. Run
+
+    ./libretro-build-vita.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-vita.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/vita`.

docs/compilation/ubuntu.md

@@ -0,0 +1,125 @@
+# Ubuntu Compilation / Development Guide
+
+## Environment configuration
+
+The easiest route to get into building RetroArch and libretro cores on Ubuntu linux is to use libretro's PPA.
+For stable releases you can add the PPA like this:
+
+    # add-apt-repository ppa:libretro/stable
+    # apt-get update
+
+For development work we recommend the testing PPA instead:
+
+    # add-apt-repository ppa:libretro/testing
+    # apt-get update
+
+You will need **git** and a few build tools at least to proceed which you can install by issuing the following command:
+
+    # apt-get install git build-essential
+
+## RetroArch Compilation
+### Building RetroArch
+
+The first step is to obtain RetroArch's source tree.
+
+    $ git clone https://github.com/libretro/RetroArch.git retroarch
+
+You can get RetroArch's dependenencies by running the following command:
+
+    # apt-get build-dep retroarch
+
+!!! Note
+    Depending on your configuration you may need to uncomment the *deb-src* repositories in */etc/apt/sources.list*, */etc/apt/sources.list.d/libretro-ubuntu-testing-$version.list* and then run **apt-get update** before running **apt-get build-dep**
+
+For subsequent builds you will need to pull the changes from the repo
+
+    $ cd retroarch
+    $ git pull
+
+To compile RetroArch run the following commands inside RetroArch's source tree:
+
+    $ ./configure
+    $ make clean
+    $ make -j4
+
+For development purposes you might want to run a debug build instead. In such case use the following commands:
+
+    $ ./configure
+    $ make clean
+    $ make DEBUG=1 GL_DEBUG=1 -j4
+
+You can then start RetroArch by running:
+
+    $ ./retroarch
+
+!!! tip
+    If you're building frequently you may want to add **ccache** to the mix to speed up the build process. 
+    Install ccache via apt and the prepend the ccache symlink directory to your build environment path as shown below. 
+    
+    For further instructions check the [documentation](https://ccache.samba.org/manual.html#_run_modes)
+
+Install **ccache**:
+
+    # apt-get install ccache
+
+Configure paths:
+
+    $ export PATH=/usr/lib/ccache/bin/:$PATH
+
+!!! tip
+    You can add that last line to your *~/.bashrc* to avoid having to type that every time you start your working environment.
+## Core Compilation
+
+### Fetching Cores
+
+You can find the cores on libretro's [GitHUB organization](https://github.com/libretro/). 
+
+We have an all-in-one tool to fetch and compile cores which you can use to streamline the process.
+You can obtain the tool by using these commands:
+
+    $ git clone https://github.com/libretro/libretro-super.git
+    $ cd libretro-super
+
+Then you can fetch one or all the cores by using **libretro-fetch.sh**
+
+Fetch all cores:
+
+    $ ./libretro-fetch.sh
+
+Fetch one core:
+
+    $ ./libretro-fetch.sh *corename*
+
+!!! Note
+     Replace *corename* with the name of the core you want to fetch, for example gambatte
+
+### Building Cores
+
+#### LibRetro Super
+
+The easiest way to build all the cores is to use **libretro-build.sh** from within libretro-super's source tree:
+
+    $ ./libretro-build.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order:
+
+    $ ./libretro-build.sh snes9x2010 fceumm
+
+Once compilation has finished, you can find the libretro cores inside *dist/unix*.
+
+#### Manual Fetching and Compilation
+
+Get the core's source tree. As an example we'll use [fceumm](https://github.com/libretro/libretro-fceumm/)
+
+    $ git clone https://github.com/libretro/libretro-fceumm.git
+
+Then compile the core: 
+
+    $ cd libretro-fceumm
+    $ make -f Makefile.libretro
+
+Optionally strip the build product:
+
+    $ strip fceumm_libretro.so
+    
+Most cores will build with these instructions. You might need to browse to a subdirectory in some cases.

docs/compilation/wii.md

@@ -0,0 +1,79 @@
+# Nintendo Wii Compilation / Development Guide
+
+## Environment configuration
+
+You need the homebrew Nintendo Wii SDK libogc and Devkitpro PPC toolchain installed. 
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+First, you need to compile 'Salamander'. Salamander is the RetroArch frontend for embedded platforms for which the cores are statically linked to the frontend. It means that for each core there is a file which contains the code of the core and the frontend.
+To compile Salamander (for Wii) run:
+
+    make -f Makefile.wii.salamander
+
+Rename the file retroarch-salamander_wii.dol as boot.dol. This file is the frontend launcher for the other cores (indeed files containing core and fronend).
+
+Second, to compile RetroArch for Wii (the core and the frontend), rename the compiled core as 'libretro_wii.a' (see bellow how to compile a core), put it in the RetroArch directory and run:
+
+    make -f Makefile.griffin platform=wii
+
+!!! Note
+    RetroArch on Wii is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch Wii. This file needs to be called 'libretro_wii.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_wii.elf and retroarch_wii.dol file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory.
+
+Once inside this directory, run :
+
+    ./dist-cores.sh wii 
+
+This process will also automate the packaging process for you.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Download libretro-super from github and run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for Wii) is to use libretro-super. If not already fetched, put the codes of the cores you want compile in the libretro-super directory and run
+
+    ./libretro-build-wii.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-wii.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/wii`.

docs/compilation/wiiu.md

@@ -0,0 +1,72 @@
+# Nintendo Wii U Compilation / Development Guide
+
+## Environment configuration
+
+You need the DevkitPPC(r29) toolchain installed and the DEVKITPRO and DEVKITPPC environment variables set to the respective folders.
+
+## RetroArch Compilation
+
+### Fetching RetroArch
+
+Clone RetroArch's repository from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+    cd retroarch
+
+For subsequent builds you only need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To update your local copy from the repository run git pull
+
+### Building RetroArch separately
+
+To compile RetroArch (for Wii U) run:
+
+    make -f Makefile.wiiu
+
+!!! Note
+    RetroArch on Wii U is statically linked. With statically linked RetroArch, each executable is a separate libretro core instead of the core being separately loaded from a single executable. A pre-existing libretro library needs to be present in the root directory in order to link RetroArch Wii U. This file needs to be called 'libretro_wiiu.a'.
+
+After a few seconds/minutes you should be able to find a retroarch_wiiu.elf and retroarch_wiiu.rpx file under that directory.
+
+### Building RetroArch in bulk
+
+Instead of building each core one by one, you can build all cores as a batch task. Run from the main 'retroarch' directory:
+
+    cd dist-scripts
+
+!!! Note
+    Make sure that all the libretro cores that you want to compile are inside the 'dist-scripts' directory. you can also copy the [info files](https://github.com/libretro/libretro-super/tree/master/dist/info) and [icons](https://github.com/libretro/retroarch-assets/tree/master/pkg/wiiu) in the same directory to have them added to the package, and to generate the meta.xml files.
+
+Once inside this directory, run :
+
+    ./wiiu-cores.sh
+
+This process will also automate the packaging process for you. the output will be in `pkg/wiiu`.
+
+### Packaging RetroArch
+
+
+### Additional Tips:
+
+## Core Compilation
+
+### Fetching Cores
+
+The easiest way to fetch all the cores is to use libretro-super. Run
+
+    ./libretro-fetch.sh
+
+### Building Cores
+
+The easiest way to build all the cores (for Wii U) is to use libretro-super. Run
+
+    ./libretro-build-wiiu.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order. E.g.:
+
+    ./libretro-build-wiiu.sh snes9x2010 fceumm
+
+Once finished, you can find the libretro cores inside directory `dist/wiiu`.

docs/compilation/windows.md

@@ -0,0 +1,219 @@
+# Windows (Vista and later) Compilation / Development Guide
+
+!!! Warning
+    The MinGW toolchain we use in this guide no longer supports targeting Windows XP. Programs compiled with it will fail to start with it.
+    Please refer to one of the MSVC guides for how to target older Windows versions with Visual Studio.
+
+## Environment configuration
+
+We recommend MinGW-W64 from MSYS2. You can download MSYS2 installer from [here](http://msys2.github.io/).
+
+Follow the installation instructions and once finished start the MSYS2 shell.
+
+MSYS2 shell is a maintenance shell. We are going to use this shell to install the toolchain and other packages. First order of business is to update MSYS2. Start the MSYS2 Shell and run the following commands:
+
+    :::bash
+    $ pacman --noconfirm -Sy
+    $ pacman --needed --noconfirm -S bash pacman pacman-mirrors msys2-runtime
+
+Close MSYS2 shell and start it again, and:
+
+    :::bash
+    $ pacman --noconfirm -Su
+
+Restart MSYS2 once again. In some cases you may find out that the shell starting scripts don't work. If so check the following Note.
+
+!!! Warning
+    If you are updating from a very old MSYS2 installation you may need to update your shortcuts to reflect changes in MSYS2's subsystem. If the shell no longer works properly you need to update your shortcuts with the following targets:
+
+- MinGW-w64 Shell: `MSYS2_ROOT\msys2_shell.cmd -mingw64`
+- MinGW-w32 Shell: `MSYS2_ROOT\msys2_shell.cmd -mingw32`
+- MSYS2 Shell: `MSYS2_ROOT\msys2_shell.cmd -msys`
+
+Now we can start installing the packages we actually need.
+
+For 32-bit builds:
+
+    :::bash
+    $ pacman -S --noconfirm --needed wget git make mingw-w64-i686-toolchain mingw-w64-i686-ntldd mingw-w64-i686-zlib mingw-w64-i686-pkg-config mingw-w64-i686-SDL2 mingw-w64-i686-libxml2 mingw-w64-i686-freetype mingw-w64-i686-python3 mingw-w64-i686-ffmpeg
+
+For 64-bit builds:
+
+    :::bash
+    $ pacman -S --noconfirm --needed wget git make mingw-w64-x86_64-toolchain mingw-w64-x86_64-ntldd mingw-w64-x86_64-zlib mingw-w64-x86_64-pkg-config mingw-w64-x86_64-SDL2 mingw-w64-x86_64-libxml2 mingw-w64-x86_64-freetype mingw-w64-x86_64-python3 mingw-w64-x86_64-ffmpeg
+
+The NVIDIA CG toolkit package hasn't been updated for a while so you need to download that package manually and install with pacman. You can download the packages from sourceforge at the following locations: [32-bit](http://sourceforge.net/projects/msys2/files/REPOS/MINGW_GCC_4_9/i686/mingw-w64-i686-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz/download) / [64-bit](http://sourceforge.net/projects/msys2/files/REPOS/MINGW_GCC_4_9/x86_64/mingw-w64-x86_64-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz/download). Alternatively you can use the following commands directly:
+
+For 32-bit builds:
+
+    :::bash
+    $ wget http://sourceforge.net/projects/msys2/files/REPOS/MINGW_GCC_4_9/i686/mingw-w64-i686-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz/download -O mingw-w64-i686-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz
+    $ pacman -U mingw-w64-i686-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz
+
+For 64-bit builds:
+
+    :::bash
+    $ wget http://sourceforge.net/projects/msys2/files/REPOS/MINGW_GCC_4_9/x86_64/mingw-w64-x86_64-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz/download -O mingw-w64-x86_64-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz
+    $ pacman -U mingw-w64-x86_64-nvidia-cg-toolkit-3.1-2-any.pkg.tar.xz
+
+Once these packages are installed close MSYS2 shell and open MinGW-w32 shell or MinGW-w64 shell depending on the platform you want to build for.
+
+## RetroArch Compilation
+### Building RetroArch
+
+The first step is to obtain RetroArch's source tree.
+You can find the repository directly at [GitHub](https://github.com/libretro/RetroArch)
+
+Start the MINGW64 or the MINGW32 shell depending on what you want to compile and run the following commands:
+
+    :::bash
+    $ git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    :::bash
+    $ cd retroarch
+    $ git pull
+
+To compile RetroArch run the following commands inside RetroArch's source tree:
+
+    :::bash
+    $ ./configure
+    $ make clean
+    $ make -j4
+
+For development purposes you might want to run a debug build instead. In such case use the following commands:
+
+    :::bash
+    $ ./configure
+    $ make clean
+    $ make DEBUG=1 GL_DEBUG=1 -j4
+
+After a few minutes you should be able to find retroarch.exe under that directory. To start the newly compiled retroarch you can use:
+
+    :::bash
+    $ ./retroarch
+
+### Packaging RetroArch
+
+You might not be able to start your own build outside that environment. You might want to try to get all the required DLLs by using the following script:
+
+    :::bash
+    $ for i in $(seq 3); do for bin in $(ntldd -R *exe | grep -i mingw | cut -d">" -f2 | cut -d" " -f2); do cp -vu "$bin" . ; done; done;
+
+If you really want to get the required libraries for distribution or for personal use on other devices and LDD doesn't work for you for whatever reason, then you can try [Dependency Walker](http://www.dependencywalker.com/). 
+
+!!! tip
+    If you're building frequently you may want to add **ccache** to the mix to speed up the build process. 
+    Install ccache via the package manager and the prepend the ccache symlink directory to your build environment path as shown below. 
+    
+    For further instructions check the [documentation](https://ccache.samba.org/manual.html#_run_modes)
+
+Install **ccache** for 32-bit builds:
+
+    :::bash
+    $ pacman -S --noconfirm --needed make mingw-w64-i686-ccache
+
+Install **ccache** for 64-bit builds:
+
+    :::bash
+    $ pacman -S --noconfirm --needed mingw-w64-x86_64-ccache
+
+Configure paths for 32-bit builds:
+
+    :::bash
+    $ export PATH=/mingw32/lib/ccache/bin/:$PATH
+
+Configure paths for 64-bit builds:
+
+    :::bash
+    $ export PATH=/mingw64/lib/ccache/bin/:$PATH
+
+!!! tip
+    You can add that last line to your *~/.bashrc* to avoid having to type that every time you start your working environment.
+
+From our own buildbot, the times with and without **ccache** are the following:
+
+Without **ccache**:
+
+    real    2m7.645s
+    user    0m2.585s
+    sys     0m11.527s
+
+With **ccache**:
+
+    real    0m25.466s
+    user    0m2.902s
+    sys     0m9.952s
+
+!!! tip
+    You can also strip the debug symbols of the build product to save some space.
+
+Strip **retroarch**: 
+
+    :::bash
+    $ strip -s retroarch.exe
+
+## Core Compilation
+
+### Fetching Cores
+
+You can find the cores on libretro's [GitHUB organization](https://github.com/libretro/). 
+
+We have an all-in-one tool to fetch and compile cores which you can use to streamline the process.
+You can obtain the tool by using these commands:
+
+    :::bash
+    $ git clone https://github.com/libretro/libretro-super.git
+    $ cd libretro-super
+
+Then you can fetch one or all the cores by using **libretro-fetch.sh**
+
+Fetch all cores:
+
+    :::bash
+    $ ./libretro-fetch.sh
+
+Fetch one core:
+
+    :::bash
+    $ ./libretro-fetch.sh *corename*
+
+!!! Note
+     Replace *corename* with the name of the core you want to fetch, for example gambatte
+
+### Building Cores
+
+#### LibRetro Super
+
+The easiest way to build all the cores is to use **libretro-build.sh** from within libretro-super's source tree:
+
+    :::bash
+    $ ./libretro-build.sh
+
+In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order:
+
+    :::bash
+    $ ./libretro-build.sh snes9x2010 fceumm
+
+Once compilation has finished, you can find the libretro cores inside *dist/win*.
+
+#### Manual Fetching and Compilation
+
+Get the core's source tree. As an example we'll use [fceumm](https://github.com/libretro/libretro-fceumm/)
+
+    :::bash
+    $ git clone https://github.com/libretro/libretro-fceumm.git
+
+Then compile the core: 
+
+    :::bash
+    $ cd libretro-fceumm
+    $ make -f Makefile.libretro
+
+Optionally strip the build product:
+
+    :::bash
+    $ strip fceumm_libretro.dll
+    
+Most cores will build with these instructions. You might need to browse to a subdirectory in some cases.

docs/compilation/windows95-msvc-cmdline.md

@@ -0,0 +1,65 @@
+# Windows (95/98/NT4) Command-line Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch on the command-line targeting Windows 95, Windows 98 or Windows NT4, we will use a combination of the MSYS2 shell and Microsoft Visual Studio .NET 2003.
+
+This guide assumes the host OS is Windows Vista or later, as MSYS2 cannot be installed on anything older.
+
+Prerequisites:
+
+Visual Studio .NET 2003
+
+[Windows Server 2003 SP1 Platform SDK](https://www.microsoft.com/en-us/download/details.aspx?id=12261)
+
+!!! Note
+    Windows 95 does not support DirectX 9.0, and NT4 does not support DirectX higher than 3.0a.
+
+!!! Note
+    In lieu of having to install the full Visual Studio suite, a minimal toolchain can be created by copying the `Common7` and `Vc7` folders from an installation on another machine (usually located at `C:\Program Files (x86)\Microsoft Visual Studio .NET 2003`). For this example we will use a root folder of `C:\mini-msvc` to hold everything, and those two folders from the MSVC installation will be copied into a directory under the root folder called `msvc2003`.
+
+!!! Note
+    The same thing can be done with the Platform SDK, just copy the `Include` and `Lib` folders from an existing installation (usually located in `C:\Program Files (x86)\Microsoft Platform SDK`) into a folder in the root such as `plat2003sp1`.
+
+## RetroArch Compilation
+### Building RetroArch
+
+First you will need the MSYS2 distribution. You can download the MSYS2 installer from [here](http://msys2.github.io/).
+
+Follow the installation instructions and once finished start the MSYS2 shell.
+
+First we need to install the `make` package:
+
+    pacman -S make
+
+Then we need to obtain RetroArch's source tree.
+
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch):
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, run:
+
+    make -f Makefile.griffin platform=windows_msvc2003_x86
+
+DirectX support is disabled by default since 95/NT do not support DirectX 9.0, but if you will only be running on higher versions of Windows, you can re-enable it by adding `HAVE_DIRECTX=1` to the end of the command line.
+
+### Minimal Toolchain
+
+If you are only using a minimal toolchain as described above, you can instead specify the location of the `msvc2003` and `plat2003sp1` folders like this:
+
+    make -f Makefile.griffin platform=windows_msvc2003_x86 VS71COMNTOOLS="c:\\mini-msvc\\msvc2003\\Common7\\Tools\\" INETSDK="c:\\mini-msvc\\plat2003sp1"
+
+!!! Note
+    The trailing slash at the end of the COMNTOOLS variable is mandatory.
+
+Also, any of the paths can optionally be left out to use the system version instead.
+
+### Finished
+
+After the build is finished you should be able to find retroarch.exe in the current directory. To start the newly compiled retroarch, copy the .exe file to a new folder where its configuration files and folders will be automatically created on first run. Running the .exe file inside of the source directory is not recommended as it will overwrite existing files.

docs/compilation/windows98-msvc-cmdline.md

@@ -0,0 +1,67 @@
+# Windows (98 SE/ME/2000) Command-line Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch on the command-line targeting Windows NT4, Windows 98SE, Windows Millenium Edition or Windows 2000, we will use a combination of the MSYS2 shell and Microsoft Visual C++ 2005.
+
+This guide assumes the host OS is Windows Vista or later, as MSYS2 cannot be installed on anything older.
+
+Prerequisites:
+
+[DirectX SDK February 2005](https://s3.amazonaws.com/bparker/dxsdk_feb2005.exe) (any version up to December 2006 should work to target 98SE)
+
+[Visual C++ 2005 Express](http://download.microsoft.com/download/A/9/1/A91D6B2B-A798-47DF-9C7E-A97854B7DD18/VC.iso) (or Pro)
+
+[Windows Server 2003 SP1 Platform SDK](https://www.microsoft.com/en-us/download/details.aspx?id=12261)
+
+!!! Note
+    Windows 98 Second Edition is supported, but First Edition has not been tested. If you do try to target it, make sure that your DirectX SDK is no newer than July 2004.
+
+!!! Note
+    In lieu of having to install the full Visual Studio suite, a minimal toolchain can be created by copying the `Common7` and `VC` folders from an installation on another machine (usually located at `C:\Program Files (x86)\Microsoft Visual Studio 8`). For this example we will use a root folder of `C:\mini-msvc` to hold everything, and those two folders from the MSVC installation will be copied into a directory under the root folder called `msvc2005`.
+
+!!! Note
+    The same thing can be done with the DirectX and Platform SDKs, just copy the `Include` and `Lib` folders from an existing installation (usually located at `C:\Program Files (x86)` in `Microsoft DirectX SDK (June 2010)` and `Microsoft Platform SDK` respectively) into folders in the root such as `dx9_june2010` and `plat2003sp1`.
+
+## RetroArch Compilation
+### Building RetroArch
+
+First you will need the MSYS2 distribution. You can download the MSYS2 installer from [here](http://msys2.github.io/).
+
+Follow the installation instructions and once finished start the MSYS2 shell.
+
+First we need to install the `make` package:
+
+    pacman -S make
+
+Then we need to obtain RetroArch's source tree.
+
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch):
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, run:
+
+    make -f Makefile.griffin platform=windows_msvc2005_x86
+
+If you do not want to compile in DirectX support, you can add `HAVE_DIRECTX=0` to the end of the command line. Currently it is necessary to disable DirectX support when targeting NT4.
+
+### Minimal Toolchain
+
+If you are only using a minimal toolchain as described above, you can instead specify the location of the folders `msvc2005`, `dx9_feb2005` and `plat2003sp1` like this:
+
+    make -f Makefile.griffin platform=windows_msvc2005_x86 VS80COMNTOOLS="c:\\mini-msvc\\msvc2005\\Common7\\Tools\\" INETSDK="c:\\mini-msvc\\plat2003sp1" DXSDK_DIR="c:\\mini-msvc\\dx9_feb2005"
+
+!!! Note
+    The trailing slash at the end of the COMNTOOLS variable is mandatory.
+
+Also, any of the paths can optionally be left out to use the system version instead.
+
+### Finished
+
+After the build is finished you should be able to find retroarch.exe in the current directory. To start the newly compiled retroarch, copy the .exe file to a new folder where its configuration files and folders will be automatically created on first run. Running the .exe file inside of the source directory is not recommended as it will overwrite existing files.

docs/compilation/windows98.md

@@ -0,0 +1,61 @@
+# Windows (98/2000) Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch targetting Windows 98 and 2000, we will use Microsoft Visual C++ 2005. This is the last version of Visual C++ that can target 98/2000.
+
+This guide assumes the host OS is Windows 2000 Professional. VC2005 does run on Windows XP and Vista but this has not been tested with RetroArch.
+
+Prerequisites:
+
+[Windows 2000 Service Pack 4](https://web.archive.org/web/20051022095019/http://download.microsoft.com/download/e/6/a/e6a04295-d2a8-40d0-a0c5-241bfecd095e/w2ksp4_en.exe)
+
+[Windows 2000 Update Rollup 1](https://web.archive.org/web/20060320020710/http://download.microsoft.com/download/2/7/b/27b1d1a3-0299-4336-b88a-22b9f09817e2/Windows2000-KB891861-v2-x86-ENU.EXE)
+
+[Internet Explorer 6](https://s3.amazonaws.com/bparker/ie60.exe)
+
+[Internet Explorer 6 Service Pack 1](https://s3.amazonaws.com/bparker/IE6.0SP1-KB2722913-WINDOWS2000-X86-ENU.EXE) (required by VC2005)
+
+[DirectX SDK February 2005](https://s3.amazonaws.com/bparker/dxsdk_feb2005.exe) (versions after this date will not install on Windows 2000)
+
+[Windows Server 2003 SP1 Platform SDK](https://www.microsoft.com/en-us/download/details.aspx?id=12261)
+
+[Visual C++ 2005 Express](http://download.microsoft.com/download/A/9/1/A91D6B2B-A798-47DF-9C7E-A97854B7DD18/VC.iso) (or Pro)
+
+!!! Note
+    Windows 98 Second Edition is supported, but First Edition has not been tested. If you do try to target it, make sure that your DirectX SDK is no newer than July 2004.
+
+## RetroArch Compilation
+### Building RetroArch
+
+!!! Note
+    Setting up a working git shell is beyond the scope of this document. [msysgit 1.8.5.2](https://github.com/msysgit/msysgit/releases/download/Git-1.8.5.2-preview20131230/Git-1.8.5.2-preview20131230.exe) is known to work locally but is unable to communicate with any remote servers on Windows 2000, and the github website does not load in IE6 either.
+
+The first step is to obtain RetroArch's source tree.
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch)
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, first open the solution file located at pkg/msvc/RetroArch-msvc2005.sln with Visual C++ 2005.
+
+Next we select the desired solution configuration:
+
+![configurations](https://s3.amazonaws.com/retroarch/msvc2005-targets.png)
+
+The choices are:
+
+    Debug
+    Debug NoAccel
+    Release
+    Release NoAccel
+
+For development purposes you can use the Debug configurations, otherwise use Release. The "NoAccel" versions do not include Direct3D or OpenGL support (but keeps DirectInput and DirectSound support).
+
+Now press F7 to build the solution, or go to Build -> Build Solution.
+
+After the build is finished you should be able to find RetroArch-msvc2005.exe in the pkg/msvc/msvc-2005/&lt;configuration&gt; directory, where `<configuration>` is the one you chose earlier such as Debug or Release. To start the newly compiled retroarch you can press F5 in Visual C++ or simply navigate to the .exe file and run it there.

docs/compilation/windowsNT351-msvc-cmdline.md

@@ -0,0 +1,57 @@
+# Windows (NT3.51) Command-line Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch on the command-line targetting Windows NT3.51, we will use a combination of the MSYS2 shell and Microsoft Visual C++ 6.
+
+This guide assumes the host OS is Windows Vista or later, as MSYS2 cannot be installed on anything older.
+
+Prerequisites:
+
+Visual C++ 6
+
+[Windows Server 2003 SP1 Platform SDK](https://www.microsoft.com/en-us/download/details.aspx?id=12261)
+
+!!! Note
+    In lieu of having to install the full Visual Studio suite, a minimal toolchain can be created by copying the `Common` and `VC98` folders from an installation on another machine (usually located at `C:\Program Files (x86)\Microsoft Visual Studio`). For this example we will use a root folder of `C:\mini-msvc` to hold everything, and those two folders from the MSVC installation will be copied into a directory under the root folder called `msvc6`.
+
+!!! Note
+    The same thing can be done with the Platform SDK, just copy the `Include` and `Lib` folders from an existing installation (usually located in `C:\Program Files (x86)\Microsoft Platform SDK`) into a folder in the root such as `plat2003sp1`.
+
+## RetroArch Compilation
+### Building RetroArch
+
+First you will need the MSYS2 distribution. You can download the MSYS2 installer from [here](http://msys2.github.io/).
+
+Follow the installation instructions and once finished start the MSYS2 shell.
+
+First we need to install the `make` package:
+
+    pacman -S make
+
+Then we need to obtain RetroArch's source tree.
+
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch):
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, run:
+
+    make -f Makefile.griffin platform=windows_msvc6_x86
+
+### Minimal Toolchain
+
+If you are only using a minimal toolchain as described above, you can instead specify the location of the `msvc6` and `plat2003sp1` folders like this:
+
+    make -f Makefile.griffin platform=windows_msvc6_x86 VCDIR="c:\\mini-msvc\\msvc6\\VC98" INETSDK="c:\\mini-msvc\\plat2003sp1"
+
+Also, any of the paths can optionally be left out to use the system version instead.
+
+### Finished
+
+After the build is finished you should be able to find retroarch.exe in the current directory. To start the newly compiled retroarch, copy the .exe file to a new folder where its configuration files and folders will be automatically created on first run. Running the .exe file inside of the source directory is not recommended as it will overwrite existing files.

docs/compilation/windowsXP-msvc-cmdline.md

@@ -0,0 +1,67 @@
+# Windows (XP and later) Command-line Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch on the command-line targetting Windows XP or later, we will use a combination of the MSYS2 shell and Microsoft Visual Studio 2010.
+
+This guide assumes the host OS is Windows Vista or later, as MSYS2 cannot be installed on anything older.
+
+Prerequisites:
+
+[DirectX SDK June 2010](https://www.microsoft.com/en-us/download/details.aspx?id=6812)
+
+[Visual Studio 2010 Express](http://web.archive.org/web/20161014172355/http://download.microsoft.com/download/1/E/5/1E5F1C0A-0D5B-426A-A603-1798B951DDAE/VS2010Express1.iso) (or Pro)
+
+!!! Note
+    The Express version does not come with a 64-bit compiler.
+
+[Visual Studio 2010 Service Pack 1](http://web.archive.org/web/20160401071422/http://download.microsoft.com/download/E/B/A/EBA0A152-F426-47E6-9E3F-EFB686E3CA20/VS2010SP1dvd1.iso) (needed for the multi-language support in RetroArch)
+
+!!! Note
+    In lieu of having to install the full Visual Studio suite, a minimal toolchain can be created by copying the `Common7` and `VC` folders from an installation on another machine (usually located at `C:\Program Files (x86)\Microsoft Visual Studio 10.0`). For this example we will use a root folder of `C:\mini-msvc` to hold everything, and those two folders from the MSVC installation will be copied into a directory under the root folder called `msvc2010`.
+
+!!! Note
+    The same thing can be done with the DirectX SDK, just copy the `Include` and `Lib` folders from an existing installation (usually located at `C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)`) into a folder in the root such as `dx9_june2010`.
+
+## RetroArch Compilation
+### Building RetroArch
+
+First you will need the MSYS2 distribution. You can download the MSYS2 installer from [here](http://msys2.github.io/).
+
+Follow the installation instructions and once finished start the MSYS2 shell.
+
+First we need to install the `make` package:
+
+    pacman -S make
+
+Then we need to obtain RetroArch's source tree.
+
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch):
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, run:
+
+    make -f Makefile.griffin platform=windows_msvc2010_x86
+
+Replace x86 with x64 if you would like a 64-bit build instead of 32-bit. If you do not want to compile in DirectX support, you can add `HAVE_DIRECTX=0` to the end of the command line.
+
+### Minimal Toolchain
+
+If you are only using a minimal toolchain as described above, you can instead specify the location of the `msvc2010` and `dx9_june2010` folders like this:
+
+    make -f Makefile.griffin platform=windows_msvc2010_x86 VS100COMNTOOLS="c:\\mini-msvc\\msvc2010\\Common7\\Tools\\" DXSDK_DIR="c:\\mini-msvc\\dx9_june2010"
+
+!!! Note
+    The trailing slash at the end of the COMNTOOLS variable is mandatory.
+
+Also, any of the paths can optionally be left out to use the system version instead.
+
+### Finished
+
+After the build is finished you should be able to find retroarch.exe in the current directory. To start the newly compiled retroarch, copy the .exe file to a new folder where its configuration files and folders will be automatically created on first run. Running the .exe file inside of the source directory is not recommended as it will overwrite existing files.

docs/compilation/windowsXP.md

@@ -0,0 +1,52 @@
+# Windows (XP and later) Compilation / Development Guide
+
+## Environment configuration
+
+To compile RetroArch targetting Windows XP or later, we will use Microsoft Visual Studio 2010.
+
+This guide assumes the host OS is Windows XP.
+
+Prerequisites:
+
+[Windows XP Service Pack 3](https://support.microsoft.com/en-us/help/936929/information-about-windows-xp-service-pack-3) (requires SP1 or SP2 installed first)
+
+[DirectX SDK June 2010](https://www.microsoft.com/en-us/download/details.aspx?id=6812)
+
+[Visual Studio 2010 Express](http://web.archive.org/web/20161014172355/http://download.microsoft.com/download/1/E/5/1E5F1C0A-0D5B-426A-A603-1798B951DDAE/VS2010Express1.iso) (or Pro)
+
+[Visual Studio 2010 Service Pack 1](http://web.archive.org/web/20160401071422/http://download.microsoft.com/download/E/B/A/EBA0A152-F426-47E6-9E3F-EFB686E3CA20/VS2010SP1dvd1.iso) (needed for the multi-language support in RetroArch)
+
+## RetroArch Compilation
+### Building RetroArch
+
+The first step is to obtain RetroArch's source tree.
+
+If you need a git shell to work in, [msysgit 1.8.5.2](https://github.com/msysgit/msysgit/releases/download/Git-1.8.5.2-preview20131230/Git-1.8.5.2-preview20131230.exe) is known to work.
+
+You can clone the repository directly from [GitHub](https://github.com/libretro/RetroArch):
+
+    git clone https://github.com/libretro/RetroArch.git retroarch
+
+For subsequent builds you will need to pull the changes from the repo
+
+    cd retroarch
+    git pull
+
+To compile RetroArch, first open the solution file located at pkg/msvc/RetroArch-msvc2010.sln with Visual Studio 2010.
+
+Next we select the desired solution configuration:
+
+![configurations](https://s3.amazonaws.com/retroarch/msvc2010-targets.png)
+
+The choices are:
+
+    Debug
+    Debug Cg
+    Release
+    Release Cg
+
+For development purposes you can use the Debug configurations, otherwise use Release. The "Cg" versions also include support for Cg shaders used with the OpenGL video driver. These will require a separate installation of the [Nvidia Cg Toolkit](https://developer.nvidia.com/cg-toolkit).
+
+Now press F7 to build the solution, or go to Build -> Build Solution.
+
+After the build is finished you should be able to find RetroArch-msvc2005.exe in the pkg/msvc/&lt;configuration&gt; directory, where `<configuration>` is the one you chose earlier such as Debug or Release. To start the newly compiled retroarch you can press F5 in Visual C++ or simply navigate to the .exe file and run it there.

docs/guides/RGUI.md

@@ -0,0 +1,115 @@
+# RGUI RetroArch Menu Interface
+
+RGUI is a simple built-in GUI for RetroArch. It was originally introduced in the Wii port of RetroArch in order to provide the console experience, where everything is controlled from a joypad. RGUI was later refitted for PC and mobile ports.
+
+![RGUI startup screen](images/rgui/rgui.png)
+
+## Features
+
+While RGUI cannot configure absolutely everything, it can do the most common things you would want to do while using RetroArch.
+
+- Selecting libretro core
+- Load a game
+- Tweak per-libretro core options (e.g. colorization in GameBoy)
+- Load game from history (previous games played)
+- Save/load savestates
+- Configure shaders
+- Configure aspect ratios
+- Configure integer scale
+- Toggle fullscreen
+- Swap disk images (needed for PlayStation, see notes below!)
+- Take screenshots
+- Enable/disable real-time rewind
+- Simple input configuration
+- Mute/unmute audio
+- Exit RetroArch (yes, sadly :p)
+
+## Config file
+By default, RetroArch looks for a config in various places depending on OS:
+
+- **Linux/OSX**: `$XDG_CONFIG_HOME/retroarch/retroarch.cfg`, then `~/.config/retroarch/retroarch.cfg`, then `~/.retroarch.cfg`, and finally, as a fallback, `/etc/retroarch.cfg`.
+- **Windows**: `retroarch.cfg` in same folder as `retroarch.exe`, then `%APPDATA%\retroarch.cfg`.
+
+To override this, use `retroarch --config customconfig.cfg`. If you have some special options you want to store in separate config files you can use `retroarch --config baseconfig.cfg --appendconfig specialconfig.cfg`. See man-page and/or `--help` for detail.
+
+### Warning
+While you are changing settings in runtime, they are not saved to disk afterwards on PC by default. If you want RetroArch to automatically write back the config, either set `config_save_on_exit = true` in config, or enable this under Settings -> Config Save On Exit from within RGUI.
+
+By design, the config file is considered immutable as it is likely maintained by the user, and should not be overwritten behind the users back. This is not the case on consoles however, where looking at the config manually isn't really an option for most users.
+
+## Entering the menu
+
+* By default on PC, the F1 button will enter the menu.
+* To exit the menu, use F1 or `Resume Game`.
+* To start immediately in RGUI without any game or core loaded, use the `--menu` command line option. As a special case, if no arguments are received, it is treated the same as running `retroarch --menu`.
+
+Menu toggle button can be mapped to joypad as well, see option `input_menu_toggle` option in `retroarch.cfg`.
+
+## Navigating the menu
+
+RGUI is controlled like any other libretro core. Regular input binds will apply, and binds here are defined in terms of the RetroPad, RetroArch's joypad abstraction.
+
+- **A button** (Default PC: X): Accept/OK
+- **B button** (Default PC: Z): Back/Cancel
+- **Start** (Default PC: Return): Go to main settings menu
+- **Select** (Default PC: Right shift): Set a setting to default
+- **Up/Down D-pad** (Default PC: Up/Down keys): Browse settings/files
+- **Left/Right D-pad** (Default PC: Left/Right keys): Toggle settings, or browse several items at once in file browser.
+
+### Searching through lists with keyboard
+When using a keyboard, it can be slow to navigate a large list using gamepad-like controls. To help this, you can type `/` (forward slash) at any time to bring up a search-box. Type a search string and hit return. The cursor should jump to the first entry that matches. The search will match mid-path strings. However, if a match is found at the beginning of the path, like when searching for first letter, the start-of-path match will take priority.
+
+The forward slash is recognized on character basis, not on the key itself. This allows e.g. norwegian layouts to type forward slash using shift + 7. Characters which are outside the ASCII set are recognized but ignored as RGUI cannot render such characters anyways.
+
+## Starting a game
+
+* To load a game you need a libretro core to use, and a ROM.
+* Selecting `Core` from top menu, you can browse for a libretro implementation.
+* Where the browser starts depends on your `libretro_path` config.
+* If blank, it will start in root (tedious to browse). If `libretro_path` is a directory, RGUI will use that as top folder. If `libretro_path` is a full path, it will start in the folder where the file is.
+
+After loading a libretro core, you will see the name and version of the core in lower part of screen. You can then browse for a ROM with `Load Game`. To control where RGUI starts to browse for roms, set `rgui_browser_directory` in config. If not set, it'll start in root.
+
+The browser will filter out extensions for the last core set in `Core`, and use that core when a ROM is loaded. If `libretro_path` in config is set with a full path to a core, this core is automatically selected once RGUI boots up (but you can still change the core afterwards).
+
+### Applying shaders
+The fundamental options are:
+
+- **Apply Shader Changes**: After changing shader settings, use this to apply changes. Changing shader settings is a somewhat expensive operation so it has to be done explicitly.
+- **Default Filter**: Choose hardware filter to use if a shader pass is not explicitly defined.
+- **Load Shader Preset**: Load a Cg/GLSL preset directly. The RGUI shader menu is updated accordingly. If the CGP uses scaling methods which are not simple, (i.e. source scaling, same scaling factor for X/Y), the scaling factors displayed in RGUI might not be correct.
+- **Shader Passes**: Number of shader passes to use. If you set this to 0, and use Apply Shader Changes, you use a "blank" shader. The Default Filter option will affect the stretching filter.
+
+For every shader pass you can configure:
+- **Shader #N**: Path to shader. All shaders must be of the same type (i.e. .cg or .glsl). Set `video_shader_dir` in config to set where browser starts to look for shaders.
+- **Shader #N Filter**: Hardware filter. If "don't care" is set, Default Filter will be used.
+- **Shader #N Scale**: Scale for this pass. The scale factor accumulates, i.e. 2x for first pass and 2x for second pass will give you a 4x total scale. If there is a scale factor for last pass, the result is stretched to screen with filter specificed in Default Filter. If "don't care" is set, either 1x scale or stretch to fullscreen will be used depending if it's not the last pass or not.
+
+When you apply shaders, the RGUI shader settings are saved to a temporary file (either rgui.cgp or rgui.glslp) and loaded. The file persists after RetroArch exits. The file is saved to `video_shader_dir` directory in config. If you always want to load the RGUI preset on bootup, you can set `video_shader` option to this file.
+
+### Converting Cg shaders to GLSL
+In some cases, Cg shaders cannot be supported. This goes for OpenGL ES drivers, and when EGL OpenGL contexts are used (KMS mode for instance). Using nVidia's `cgc` compiler, you can convert Cg shaders to GLSL shaders with the `cg2glsl` tool developed by us [here](https://github.com/Themaister/RetroArch/blob/master/tools/cg2glsl.py). It can convert single shaders as well as whole folder structures in batch.
+100% compatibility is not guaranteed, but almost all shaders should work fine. Cg presets (.cgp) are not converted at the moment, but converting them is as simple as copying over the .cgp, rename it to .glslp and replace references to .cg files to .glsl.
+
+## Configuring input
+Currently you can configure two settings per player (on PC):
+
+- **Device**: Picks which gamepad to use for player N. The name of the pad is available.
+- **Device Type**: Picks which device type to use. This is relevant for the libretro core itself, and mostly useful for PlayStation, which needs to know if you're using a DualAnalog device or not.
+
+### Configuring joypad input
+Configuring joypad input is supported from within RGUI.
+Normal gameplay binds as well as RGUI hotkey binding is supported. It is possible to bind everything in succession for convenience.
+
+### Configuring keyboard input
+Configuring keyboard input is currently not supported. To configure keyboard binds, it must be done outside RGUI.
+
+## PlayStation disk swapping
+Some PlayStation games require disk swapping. To manage disks, libretro has a concept of a disk index (like a multi-disk CD player, remember those? :P). If a PlayStation core is loaded, `Disk Index` and `Disk Image Append` options are added to main menu.
+
+In Mednafen PSX, multi-CD images are typically handled with an .m3u playlist. In this case, you can swap disks by cycling through the Disk Index setting. If you don't or can't use a playlist, you can append a disk image on the fly using `Disk Image Append`. In this case, you browse for a disk image and append it to the internal disk image list. The `Disk Index` is updated appropriately and you are returned to the game.
+
+### Workarounds
+Replacing the disk inside RGUI is "physically" speaking the same as ejecting, swapping disks and closing the tray instantanously. Some games will not work with this approach, notably Metal Gear Solid because they need to detect an actual eject taking place.
+
+To work around this, set `Disk Index` to `No Disk`, and exit RGUI. The game will pick up that the tray has been ejected/missing disk after half a second or so. Now you can go back to RGUI, pick the correct disk index and return to the game.

docs/guides/cli-intro.md

@@ -0,0 +1,32 @@
+# RetroArch CLI
+
+RetroArch can be utilized via its robust graphical interfaces as well as a powerful command-line interface (CLI). Getting familiar with the command-line helps you understand the design principles of RetroArch.
+
+Note: please be aware of whether your system uses DOS/Windows style paths with backslashes `\` or Unix-style paths with forward slashes: `/`.
+
+#### Loading a ROM and libretro core (Unix-style path)
+    retroarch -L /path/to/libretro/core.so game.rom
+    
+#### Loading a ROM and libretro core with flatpak
+    retroarch -L /path/to/libretro/core.so game.rom
+    flatpak run org.libretro.RetroArch/x86_64/stable -L /home/MYUSERNAME/.var/app/org.libretro.RetroArch/config/retroarch/cores/nestopia_libretro.so Tetris.nes
+
+
+## Verbose logging output
+To get a better idea on what's going on, use the `--verbose` flag. If you want to report a bug, it is **vital** that this log is included.
+
+## Using a config file
+By default, RetroArch looks for a config in various places depending on OS:
+
+- **Linux/OSX**: `$XDG_CONFIG_HOME/retroarch/retroarch.cfg`, then `~/.config/retroarch/retroarch.cfg`, then `~/.retroarch.cfg`, and finally, as a fallback, `/etc/retroarch.cfg`.
+- **Windows**: `retroarch.cfg` in same folder as `retroarch.exe`, then `%APPDATA%\retroarch.cfg`.
+
+To override this, use `retroarch --config customconfig.cfg`. If you have some special options you want to store in separate config files, you can use `retroarch --config baseconfig.cfg --appendconfig specialconfig.cfg`. Be sure to pass `--menu` as well if you aren't loading content directly from the command-line, or RetroArch will close immediately after launching. See man-page and/or `--help` for detail.
+
+## Other essential CLI flags
+
+### retroarch --help
+Use the `--help` help flag to display RetroArch's built-in CLI documentation. You'll probably discover some features you didn't think about.
+
+### retroarch --features
+If you're unsure if a particular feature is compiled in, execute `retroarch --features`

docs/guides/extensions.md

@@ -0,0 +1,56 @@
+## CUE
+
+- 4DO
+- Genesis Plus GX
+- Beetle PCE Fast + Beetle SGX
+- Beetle PC-FX
+- Yabause
+- Reicast
+- PicoDrive
+- Beetle PSX + Beetle PSX HW
+- Beetle Saturn
+- PCSX ReARMed
+
+## M3U
+
+- blueMSX
+- Beetle PSX + Beetle PSX HW
+- Beetle Saturn
+- PCSX ReARMed
+- PX68k
+
+## CHD
+
+- Genesis Plus GX
+- MAME 2000
+- MAME 2009
+- MAME 2010
+- MAME 2014
+- MAME 2016
+- MAME
+- MESS 2014
+- Beetle Saturn
+- Beetle PSX + Beetle PSX HW
+- Beetle PC-FX
+- Beetle PCE FAST
+- Beetle SGX
+- Redream
+- Reicast
+- UME 2014
+
+## PBP
+
+- Beetle PSX + Beetle PSX HW
+- PCSX ReARMed
+- PPSSPP
+
+## Disk Control
+
+- Beetle PSX + Beetle PSX HW
+- Beetle Saturn
+- PCSX ReARMed
+- PicoDrive
+- PX68k
+- blueMSX
+- Neko Project II Kai
+- VICE

docs/guides/generating-retroarch-logs.md

@@ -0,0 +1,117 @@
+## What are logs? Why are they so important?
+
+RetroArch and its underlying libretro technology is designed to run on many different combinations of hardware, operating system, libretro core, and content. It is not possible for a volunteer-based open source project to test all possible combinations.
+
+The answer to this dilemma involves "logs", which RetroArch and other libretro software use to record essential information about your system and its function that other users and volunteers need in order to help troubleshoot problems and improve compatibility with new systems.
+
+--------------------------
+
+## Generating Logs
+
+### Generating Logs in Lakka
+[Please see the Troubleshooting Lakka doc](http://www.lakka.tv/doc/Troubleshooting-Lakka/).
+
+### Generating Logs in Linux
+
+#### RetroArch logs
+1. Open a terminal.
+2. Navigate to the RetroArch folder with the `cd` command.
+3. Start retroarch in 'verbose' mode with this command:<br />
+ `retroarch --menu --verbose >> retroarch.log 2>&1`
+4. Once you exit RetroArch, a file called `retroarch.log` should be stored in your home directory.
+
+#### Graphic card logs
+`lspci -nnk | grep -A 3 VGA` will give information about your graphic card.
+
+#### Audio device logs
+`aplay -L` enumerates audio devices which have been detected.
+
+#### Input device logs
+`lsusb` lists all devices attached via USB
+
+`dmesg` displays all messages from the kernel ring buffer which typically is holding the messages generated by the Linux kernel from the boot process. The dmesg log lists each hardware device that the kernel detected along with information on how the device was configured by the system.
+
+### Generating Logs in Windows
+
+
+If you **installed** RetroArch:
+
+1. Open the Windows start menu
+2. Search and open `RetroArch (log to file)`
+
+Once you exit RetroArch, a file called `retroarch-log.txt` should be stored in the RetroArch folder, in order to retrieve it:
+
+1. Open the windows start menu
+2. Search and open `RetroArch Data Folder`
+3. Find `retroarch-log.txt`
+
+
+If you **haven't installed** RetroArch and have a folder with it:
+
+!!! tip
+    You can hold `shift` then `right click` on the **folder that contains** retroarch.exe <br />
+    Select `Open PowerShell window here`.<br />
+    Then jump to step 3.
+
+1. Open a console window with the `cmd` command, found either in the Start Menu or through use of the Windows "Run" menu. 
+2. Navigate to the RetroArch folder using the `cd` command.
+3. Launch RetroArch with this commandline:<br />
+ `.\retroarch.exe --log-file .\retroarch-log.txt -v`
+4. Once you exit RetrorArch, a file called `retroarch-log.txt` should be stored in the folder.
+
+!!! note "Log with debug symbols"
+    Optionally or if asked, launch RetroArch with debug symbols with this commandline:<br />
+    `.\retroarch_debug.exe --log-file .\retroarch-log.txt -v`
+
+
+### Generating Logs in OS X
+1. Open a console window with the OS X "Terminal" app.
+2. Navigate to the RetroArch folder using the `cd` command.
+3. Launch RetroArch with this commandline:<br />
+ `retroarch --menu --verbose --log-file ~/retroarch.log`
+4. Once you exit RetroArch, a file called `retroarch.log` should be stored in your home directory.
+
+### Generating Logs in Android
+There is a range of variation in the logging systems available to Android device depending on the combination of hardware and operating system in use. There are two general approaches to generating logs in Android: tethering to a PC via a USB cable or using a `logcat` app.
+
+#### Generating Logs via USB Tether
+
+**Prerequisites**:
+* Linux, Windows or Mac PC
+* USB cable for your device
+
+**Instructions**:
+
+* Install your device driver for using adb on your PC from http://developer.android.com/tools/extras/oem-usb.html
+* Download the adb executable for your OS -- it can be downloaded as part of the [full Android SDK](https://developer.android.com/studio/index.html), but you might also be able to find the adb executable individually.
+* Connect your Android device to the PC via USB cable.
+* Enable the developer options on the Android.
+* Enable USB debugging on the Android.
+* Open a command prompt (Windows) or terminal (Linux/OS X) and navigate to the directory where the adb executable is located using the `cd` command. On Windows: Windows Key + R > type `cmd` > press Enter. On OS X: Type `Terminal` into Spotlight and open it. Alternately, on Windows: Go to the directory where you downloaded the adb executable, Shift+Right Click and select `Open Console` (or similar) | On Linux / OS X: Right Click in the directory and select `Open Terminal here`
+* Type in your console window: `adb devices` to verify your device is properly connected.
+* If your device is selected, type in `adb logcat` to show the logcat, aka stacktrace.
+* Reproduce your issue on your device.
+* Paste the contents of your console window into a Github Gist to share on the forums or github.
+
+_Based on Stackexchange posts by Leandros and Nicolas Raoul._
+
+#### Generating Logs via Android App
+Gathering log files in Android requires a third-party app that can interface with the `logcat` system. Many free apps are available via Android's "Play Store" system.
+
+### Generating Logs in iOS
+At the moment there are no logging docs available for iOS. Please feel free to post about your situation in the libretro forums.
+
+### Generating Logs with Nintendo Consoles
+At the moment there are no logging docs available for Nintendo consoles. Please feel free to post about your situation in the libretro forums.
+
+### Generating Logs with PlayStation Consoles
+At the moment there are no logging docs available for PlayStation consoles. Please feel free to post about your situation in the libretro forums.
+
+
+-------------------------
+
+## Posting Logs in the Forum and Github
+
+Generally, log files are lengthy which make them difficult to read when they're pasted directly into a post on the forums or github. If your log file is more than six or seven lines long, you will be asked to post a link to it instead.
+
+One free and straightforward system for posting and sharing logs is [Github Gist](https://gist.github.com). You can paste the contents of a log file, or the log file itself, into the Gist website. After you log has been added to the Gist, press the `Create Public Gist` button to create a shareable link.

docs/guides/how-to-contribute.md

@@ -0,0 +1,20 @@
+# Contribute to the documentation
+
+The docs are written in [Markdown](https://en.wikipedia.org/wiki/Markdown) if you need help with the syntax use [this guide](https://guides.github.com/features/mastering-markdown/). <br />
+Mkdocs uses some [Markdown extensions](http://www.mkdocs.org/user-guide/writing-your-docs/#markdown-extensions) that you may have to familiarize with.
+
+The documentation source is maintained via [Git](https://en.wikipedia.org/wiki/Git)<br />
+For novice users that don't know how to use the command line you can use [Github Desktop](https://desktop.github.com/).<br />
+For more info on how to use git [refer to their help](https://help.github.com/)
+
+In order to propose improvements to a document:
+
+1. [Clone the repo](https://github.com/libretro/docs) (If you are using [Github Desktop](https://desktop.github.com/), select Clone>Open in Desktop)
+2. Make the changes and update your clone
+3. Test, [follow the Building section to render the site](https://github.com/libretro/docs/blob/master/README.md#building)
+4. Propose your changes using the button "New Pull Request" [in the docs repo](https://github.com/libretro/docs)<br />
+make sure that you are comparing **your forks edited branch** to the **docs master branch**
+
+There is a To-Do list for libretro/docs [here](https://docs.libretro.com/meta/todo/)
+
+You can submit suggestions or issues regarding documentation at the [libretro/docs issue tracker](https://github.com/libretro/docs/issues) or in our [forum thread](https://forums.libretro.com/t/wip-adding-pages-to-documentation-site/10078/).