Horde Buildgraph Integration
Overview
ADT integrates with Unreal Engine's Horde build system so that studios already using Horde can publish builds directly to ADT for distribution, without leaving their existing pipeline or adding manual steps between a successful package and a downloadable build.
The integration works through a generated build script that you configure once. After that, every BuildGraph pipeline run that produces a packaged Win64 build also publishes it to ADT automatically: creating or targeting a version, registering the build, uploading binaries, and assigning the result to the configured channel and track.
Why this integration exists
Horde is strong at orchestration: BuildGraph execution, agent scheduling, logs, and artifact production. ADT is strong after the package exists: organizing builds into versioned releases, assigning them to channels with controlled access, and distributing them to QA testers, designers, and external partners through ADT Hub.
Without an integration between the two systems, studios face a manual handoff every time a build completes. A build engineer must run the ADT CLI by hand (or maintain a custom post-build script) to move each finished build from Horde into ADT. This gap causes delays between when a build is ready and when testers can access it, and it creates a fragile dependency on whoever wrote the script.
The integration removes this handoff. Horde continues to own build orchestration. ADT becomes the distribution layer that activates automatically when a build is ready.
How the integration works
You run a single initialization command that ADT Hub generates for you, pre-filled with the correct namespace, game project, channel, and track. Running that command on the build machine produces a set of files, including start_compile.bat. Fill in three local folder paths — the Unreal Engine installation, the game project, and the build output folder — and the script is ready.
From that point, start_compile.bat handles the full publish sequence whenever it runs:
Horde BuildGraph pipeline
│ Finishes packaging (Win64 output ready)
│
↓ start_compile.bat runs the publish sequence
ADT CLI called in order:
(1) Create or target the configured version in ADT
(2) Register the Win64 build
(3) Upload binaries to ADT storage
(4) Assign the build to the configured channel and track
│
↓
Build is immediately visible in ADT Hub — available for download
The publish sequence is idempotent. If a pipeline run fails partway and is re-run, the script finds the existing version and build and continues without creating duplicates.
Version naming defaults to {Branch}-{CL} when not specified, following the common Unreal convention. You can also supply an explicit version name.
Key benefits
- No manual handoff. Once set up, builds move from Horde to ADT automatically. QA testers and stakeholders see new builds in ADT Hub within minutes of a successful pipeline run, without you needing to intervene.
- One-time configuration. The initialization command from ADT Hub generates files pre-filled with ADT-specific values. You supply only the local folder paths. There is no per-build configuration to maintain.
- Safe to re-run. The publish script is idempotent. Re-running after a failure attaches the build to the existing version rather than creating a duplicate. You can re-trigger failed pipeline runs without cleaning up ADT first.
- Credentials stay out of scripts. The ADT API key is read from an environment variable at runtime. It is never written to the generated script files, checked into source control, or visible in Horde logs.
- Non-critical publish mode. You can configure the publish step to log a warning on failure instead of halting the pipeline — useful for nightly builds where a failed ADT publish should not block downstream steps.
Limitations and considerations
Available to new namespaces only in the first release. The Get Started page, where the initialization command is generated, is shown only for newly created namespaces. If you have an existing ADT namespace, you don't have access to this setup flow in the first release. An option to enable Get Started for existing namespaces via game settings is planned for a future release.
Win64 only in the first release. The integration supports Windows (Win64) packaged builds. Linux, macOS, and console platform targets are planned for a future release.
One platform per publish run. A single publish run handles one platform. If you publish to multiple platforms, configure one script per platform target.
Channels and tracks must be created before the pipeline runs. The publish script assigns builds to existing channels and tracks in ADT. It does not create them. If a channel or track does not exist when the script runs, the publish step fails immediately with a clear error directing you to create the missing resource in ADT Hub.
ADT CLI must be pre-installed on Horde agents. The generated files depend on blackboxcli (v2.31.0 or later) being available on the system PATH of each agent machine that runs the pipeline. The CLI is not bundled with the generated files.
Large builds over 50 GB are supported but may be slow. There is no file size limit enforced by ADT. Builds over 50 GB complete successfully but transfer time increases proportionally. Resumable uploads are planned for a future release.
Concurrent publishes to the same version: last write wins. If two pipeline runs attempt to publish a Win64 build to the same version simultaneously, the last upload to complete is the one recorded. The script logs a warning when it detects an existing build on the target version.
Supported platforms
| Engine | Build target | Supported |
|---|---|---|
| Unreal Engine 5.7 | Windows (Win64) | Yes — validated |
| Unreal Engine 5.x (other) | Windows (Win64) | Best-effort |
| Unreal Engine 5.x | Linux | Planned |
| Unreal Engine 5.x | macOS | Planned |
| Unreal Engine 5.x | Console (PS5, Xbox) | Planned |
| Unity | Any | Not supported |