📚 Lesson 8.2: Integrating Third-Party Libraries

Three Kinds of Library

How you integrate a library depends on how it's distributed. There are three forms, in increasing integration effort:

Header-Only Libraries

The easiest case — a library that's entirely in headers (many modern C++ libs are). You just tell the build where the headers are.

public class MyModule : ModuleRules
{
    public MyModule(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicDependencyModuleNames.AddRange(new string[]
        { "Core", "CoreUObject", "Engine" });

        // Point the compiler at the header-only library's include folder.
        PublicIncludePaths.Add(
            Path.Combine(ModuleDirectory, "ThirdParty", "somelib", "include"));
    }
}

// Then just include and use it in your .cpp:
#include "somelib/somelib.hpp"

void UMyClass::DoThing()
{
    somelib::Widget w;   // the third-party API, now available
}

Static & Dynamic Libraries

A precompiled library adds a linking step: you point at the headers and the library binary. For a static lib, that's all — it gets baked into your module's binary.

public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
    // ... dependencies ...

    string ThirdParty = Path.Combine(ModuleDirectory, "ThirdParty", "physicslib");

    // 1) Where the headers are:
    PublicIncludePaths.Add(Path.Combine(ThirdParty, "include"));

    // 2) The library to link (platform-specific):
    if (Target.Platform == UnrealTargetPlatform.Win64)
    {
        PublicAdditionalLibraries.Add(
            Path.Combine(ThirdParty, "lib", "Win64", "physicslib.lib"));
    }
}

Shipping a DLL

A dynamic library (DLL) needs three things: the headers, an import library to link against, and — critically — the DLL itself staged next to the packaged game so it loads at runtime. Miss the last step and it works in the editor but crashes in a packaged build.

if (Target.Platform == UnrealTargetPlatform.Win64)
{
    string Bin = Path.Combine(ThirdParty, "bin", "Win64");

    // Link against the import library at build time:
    PublicAdditionalLibraries.Add(Path.Combine(ThirdParty, "lib", "Win64", "netlib.lib"));

    // Tell Unreal about the DLL that must load at runtime:
    string Dll = Path.Combine(Bin, "netlib.dll");
    PublicDelayLoadDLLs.Add("netlib.dll");

    // Stage the DLL into the packaged build's binaries:
    RuntimeDependencies.Add(
        "$(BinaryOutputDir)/netlib.dll", Dll);
}

Taming Warnings

Unreal compiles your code with strict warnings (often warnings-as-errors). Third-party headers rarely meet Unreal's bar, so including them raw can fail the build. Wrap them in Unreal's third-party include guards.

// Wrap noisy third-party includes so their warnings don't break your build:
#include "Windows/AllowWindowsPlatformTypes.h"   // (Windows-specific headers)
THIRD_PARTY_INCLUDES_START
#include "somelib/somelib.hpp"
THIRD_PARTY_INCLUDES_END
#include "Windows/HideWindowsPlatformTypes.h"

Hands-on Exercise & Quiz

Summary

📚 Additional Resources

• Integrating Third-Party Libraries (Epic)
• Unreal Build Tools (Epic)

🚀 What's Next?

You can organize your modules and pull in external code. The module finale packages your work for reuse: writing a C++ plugin — a self-contained bundle you can drop into any project or share.