# Async Loading Screen: a loading screen plugin for Unreal that avoids level streaming

> Async Loading Screen is an Unreal Engine plugin that puts a loading screen in front of every level transition without requiring level streaming, by driving MoviePlayer from the PreLoadMap and PostLoadMapWithWorld delegates so the movie and widget render on their own thread. It is MIT licensed, written in C++, and the current changelog entry adds PSO precaching awareness to the loading screen.

**truong-bui/AsyncLoadingScreen** — Async Loading Screen is a free and open-source plugin for Unreal Engine. Async Loading Screen allows you to easily configure a Loading Screen System in the project settings, and automatically add a Loading Screen whenever you open a new level, without Level Streaming.

- Repository: https://github.com/truong-bui/AsyncLoadingScreen
- Website: https://www.fab.com/listings/f8aabb9a-7c96-4f79-97ff-04bcc146e595
- Stars: 1,123 · Forks: 141
- Language: C++
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/truong-bui-asyncloadingscreen

## The problem it solves, and why level streaming is the wrong answer

The About section explains the underlying Unreal behaviour, and it is the reason the plugin exists. Loading screens are not trivial in general, especially in Unreal Engine, and the reason newcomers are confused at first is that the UserWidget is destroyed at level transition and level loading runs on the main thread, which blocks any other game activity until it completes. That is why the conventional answer is to use Level Streaming for loading screens, otherwise the widget blueprint will not work. The cost of that answer is described honestly. You have to manually control which object is loaded or unloaded, you cannot use a different Game Mode or Player Controller for each level, and sometimes there is still occasional freezing. The plugin exists so that a designer does not have to restructure the game around a level streaming mechanic to get a loading screen.

## How it works: MoviePlayer on the PreLoadMap and PostLoadMapWithWorld delegates

The How it works section is the whole technical description. Async Loading Screen uses MoviePlayer to play a movie at level transition, on a different thread than the game thread, and MoviePlayer is not only playing movie files but can also display a Slate widget on top of the movie, which is what the plugin uses for the loading screen. MoviePlayer is registered to the PreLoadMap and PostLoadMapWithWorld delegates, so it is called and shut down automatically by the engine whenever a new level is opened. The threading point is the crux, because it is the reason the widget survives the transition that normally destroys it, and the delegate registration is why you do not have to add a call to your own level blueprint.

## What the plugin gives a designer, and what it still needs from a programmer

The About section is honest about the division of labour. To create a custom loading screen without Level Streaming you have to do it in Unreal C++, which is a hard task for artists and designers, even for developers not familiar with the Slate framework and engine module code. The plugin comes to the rescue by allowing the loading screen system to be configured in the project settings, and it automatically adds a loading screen whenever a new level is opened. It ships with pre-designed UI layouts and default icons, and the README claims customisation in a few minutes. The features list adds customizable pre-made responsive layouts, customizable loading icons, pre-made default loading icons, supported animating image sequences, support on all major platforms, easily playing movies and audio files, no need for coding, no temporary maps, no level streaming, automatic handling of all level transitions, and clean integration with an existing project. The claim of no coding is about the configuration step, not about the plugin itself.

## The packaging notes, which are where packaged builds break

The IMPORTANT NOTE section is the part of the README a user must read before anything else, and every item in it is a failure that otherwise appears only in a packaged build. The texture group should be set to UI and the compression settings to UserInterface2D, because the plugin draws the screen in a context that is not the normal world rendering path. You must not package the Movies folder into the .pak file, because MoviePlayer needs to look for the startup movies folder at the Contents/Movies path, so you add the Content/Movies folder to Project Settings, Packaging, Additional Non-Asset Directories To Copy, which copies the movie files as loose files instead of packing them. And you must make sure no conflicting plugins are enabled, with Pre-Load Screen Movie Player given as the example. The same applies to background images and loading icons, which may not appear in packaged games or Quick Launch unless the asset folder is added to AdditionalAssetDirectoriesToCook, because the plugin loads at the PreLoadingScreen phase before the asset streaming system is ready, so textures must be explicitly cooked, and this applies to image sequence images as well.

## The 1.7.0 changelog: PSO precaching becomes part of the loading screen

The changelog's most recent entry, version 1.7.0 dated the twenty-fifth of July 2026, is a substantial change and it is the newest thing in the project, which is worth noting given the last tagged release listed is 1.3.0 from 2021. The new Wait For PSO Precaching To Complete option is per loading screen, and the loading screen stays up until all outstanding PSO precache compilations, both the bundled PSO cache and runtime PSO precaching, are finished, as recommended by Epic's PSO precaching documentation, so players do not see visual popping or hitches right after the loading screen closes. A PSO Precache Max Wait Time safety timeout was added, zero meaning unlimited, with a value above zero recommended especially when the project ships a bundled PSO cache. A Boost PSO Precache Priority option, on by default, boosts outstanding precache compilations to highest priority while the screen is displayed and restores it when it closes.

## The progress widget and the automatic stop

The same changelog entry adds a PSO Precache Progress Widget, with a fully styleable progress bar covering background and fill brushes, size, alignment and padding, and an optional text supporting {Percent} and {Remaining} format arguments, with an example string of Compiling Shaders... {Percent}%. The widget appears only while precache compilations are outstanding and hides itself when they are done. The behaviour notes matter for anyone automating this, because the wait takes over the Wait For Manual Stop option and forces it to true, and the plugin stops the loading screen automatically once PSO precaching finishes or times out, honouring the Minimum Loading Screen Display Time, so no StopLoadingScreen call is needed. With Minimum Loading Screen Display Time set to minus one, players can still press any key to skip.

## Installation, the tutorial and the shape of the project

The Contents section lists the tutorial, and it is the best guide to what the plugin expects from a project. The steps are to create testing levels and Blueprints, gather images and movies, set up startup movies, configure the default loading screen setting with its background, tip widget and loading widget settings, configure the classic layout setting, configure the image sequence settings, and set a proper background and tip for each level. Installation has two routes, cloning from GitHub or downloading from the Marketplace, followed by a setup step. The repository layout is a standard Unreal plugin, with AsyncLoadingScreen.uplugin as the descriptor, Source/ for the C++ module, Config/ for the settings, Content/ for the pre-made layouts and icons, Resources/ for the icon, and the LICENSE and README. The primary language is C++, the licence is MIT, and the homepage is a Fab listing.

## Where the project stands, and the gap in its release history

The facts about the upkeep are worth stating plainly because they pull in different directions. The changelog reaches version 1.7.0 dated the twenty-fifth of July 2026, and the last push to the repository was on 2026-07-27, so the work is current. The listed releases, however, show only 1.3.0 from 2021-08-29, and the repository is not archived. The explanation is visible in the README itself, since the installation section offers a download from the Marketplace as well as a clone from GitHub, while the README changelog covers the whole line. So the project is alive and the marketplace is the release channel, and the GitHub tag list is not the record of what is current. The plugin is on the Fab marketplace and free and open source under the MIT licence, and the topics list the engine generations it targets as ue4 and unreal-engine.

## Conclusion

Async Loading Screen suits an Unreal team that wants a real loading screen in front of every level transition and does not want to restructure its project around level streaming, which would otherwise constrain the game mode and player controller per level. It is the wrong choice if your project already has a working level streaming setup, since the plugin exists precisely to avoid that, and a poor fit if you cannot touch the engine, because the loading screen has to be written in Unreal C++ and the Slate framework unless you use the plugin. Before adopting it, read the important notes on the top of the README, because the texture group, the compression settings and the packaging rules for the Movies folder are not optional defaults and getting them wrong produces a screen that works in the editor and disappears in a packaged build.

## FAQ

### What does the Async Loading Screen plugin do?

It lets you configure a loading screen system in the project settings and automatically add a loading screen whenever you open a new level, without level streaming, no temporary maps and no coding for the configuration step. It ships pre-designed UI layouts and default icons, supports animating image sequences, and works on all major platforms.

### How does the Async Loading Screen plugin avoid level streaming?

It uses MoviePlayer to play a movie at level transition on a different thread than the game thread, and MoviePlayer can display a Slate widget on top of the movie, which is what the plugin uses for the loading screen. MoviePlayer is registered to the PreLoadMap and PostLoadMapWithWorld delegates so the engine calls and shuts it down automatically on a level change.

### What do I need to set up for a packaged build with Async Loading Screen?

Set the texture group to UI with compression settings UserInterface2D, do not pack the Movies folder into the .pak file but add Content/Movies to Project Settings, Packaging, Additional Non-Asset Directories To Copy, and add the background image folders to AdditionalAssetDirectoriesToCook because the plugin loads before the asset streaming system is ready. Also make sure no conflicting plugins are enabled.

### What does the Wait For PSO Precaching To Complete option do?

It keeps the loading screen up until all outstanding PSO precache compilations, both the bundled PSO cache and runtime PSO precaching, are finished, following Epic's PSO precaching documentation, so players do not see visual popping or hitches right after the screen closes. A separate PSO Precache Max Wait Time timeout of zero for unlimited is available, and a Boost PSO Precache Priority option raises compilation priority while the screen is shown.

### What is the latest version of the Async Loading Screen plugin?

The changelog's most recent entry is version 1.7.0 dated 25 July 2026, and the last push to the repository was on 2026-07-27. The listed GitHub release is 1.3.0 from 2021, with the Marketplace download being the current distribution channel. The licence is MIT and the plugin is written in C++.

## Sources

- [License: MIT](https://github.com/truong-bui/AsyncLoadingScreen/blob/master/LICENSE)
- [Project website](https://www.fab.com/listings/f8aabb9a-7c96-4f79-97ff-04bcc146e595)
- [README](https://github.com/truong-bui/AsyncLoadingScreen/blob/master/README.md)
- [Releases](https://github.com/truong-bui/AsyncLoadingScreen/releases)
- [truong-bui/AsyncLoadingScreen on GitHub](https://github.com/truong-bui/AsyncLoadingScreen)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/truong-bui-asyncloadingscreen