Starting with Aurie v2.0.0, YYToolkit can be automatically installed alongside Aurie through the Aurie Installer.

To download Aurie Installer, locate the Assets section of the release, and select AurieInstaller.exe.

Once downloaded, run the application and follow the on-screen instructions.

Manual installation is intended for power-users and people that can't run Aurie Installer.
It allows finer control over Aurie's installation, and doesn't require the .NET runtime.

1. Create the following folder structure in your game directory:

├─── GameExecutable.exe
└─── mods
    ├─── Aurie
    └─── Native

2. Place AurieCore.dll in the Native folder.
3. Place YYToolkit.dll in the Aurie folder.
4. Patch the game using AuriePatcher as outlined below:

> AuriePatcher.exe "C:\path\to\game\executable.exe" "C:\path\to\game\mods\Native\AurieCore.dll" install

Using executable: "C:\path\to\game\executable.exe"
Using native DLL path: "C:\path\to\game\mods\Native\AurieCore.dll"
File mapped to 0x000002805FC20040 => size 0x27B0A00
.aurie section at 000002805FC20380
g_OldOEP stored at 00000280623CA5D8, contains value 0x1A83F84.
Filed saved successfully. Done.

YYToolkit mods can be divided into two categories: native mods and managed mods.

Native mods are made in C++.
They have full control over the game runtime, but are more difficult to make, as they require an understanding of how the GameMaker engine operates. Their access to the engine, renderer, and other loaded mods is unrestricted. Any bug in a native mod will crash the game without an option for graceful recovery. This option is best-suited for power-users that need raw speed and low-level access without any hand-holding.

Managed mods are made in C#.
They are restricted to known-safe APIs which actively prevent any misuse of engine structures. They have been explicitely structured to make modding with YYToolkit as easy as possible while not excessively limiting functionality. Bugs in managed mods can be handled gracefully using exceptions thrown by the underlying abstraction layer.
This option is best-suited for the casual modder that prefers ease-of-use and safety over pure control.

Native mods are the core of YYToolkit. They have direct access to the interface documented on the YYToolkit wiki. For an easy walkthrough on how to set everything up for YYTK v5, see the official video guide.

If watching videos isn't your thing, the major steps are highlighted below:

1. Download and install the AurieProjectVSIX.vsix file.
2. Create a new project using the Aurie Framework Project template.
3. Inside include/Aurie, open the shared.hpp file. Replace all its contents with the up-to-date Aurie shared headers.
4. Inside include, create two directories: YYToolkit and FunctionWrapper. These will store the YYTK shared headers and their dependencies.
5. Copy all files from YYTK's shared headers into the YYToolkit folder. If the files don't appear in Visual Studio, refresh the solution explorer file view.
6. Copy all files from YYTK's FunctionWrapper into the FunctionWrapper folder. If the files don't appear in Visual Studio, refresh the solution explorer file view.
7. Inside the solution explorer, right-click on the include folder, and select Include in project.

By default, the Aurie Framework Project template does not detect any additional modules' headers being installed. To access YYToolkit's headers, remove the #include <Aurie/shared.hpp> line in ModuleMain.cpp, and replace it with #include <YYToolkit/YYTK_Shared.hpp>.

To access YYToolkit's interface, use the YYTK::GetInterface() function. This function may return nullptr if the YYToolkit core module is not loaded.

Similarly to native mods, managed mods utilize Visual Studio as a build environment. The C# build environment must be installed via Visual Studio's installer.

Once you've set up Visual Studio, see the Creating your first mod page on the AurieSharp wiki.

When making YYToolkit mods, the debugger is your best friend. In both native and managed mods, it can be used to inspect the game's state. The debugger also catches any exceptions before they crash your program, as you can step through problematic code and inspect the local state line-by-line.

When debugging a managed mod, the debugger gets even stronger - it can automatically infer types from game variables, and parse C# code on the fly. This allows you to fully control the game from just the command window, while also enabling exploration of game objects without the need for a single line of code.

1. Create breakpoints in your code.
2. Launch the game with YYToolkit and your mod.
3. Use Visual Studio's Debugger to attach to the game process.