Lead Concept Artist

Fortnite is hosting a Mandalorian & Grogu Watch Party Island. Fortnite is no longer just the place where Star Wars characters show up, swing lightsabers, and make Darth Vader do things no Sith Lord should ever do in public. Now it is becoming a movie preview venue. Epic Games and Lucasfilm are launching The Mandalorian and Grogu Watch Party Island inside Fortnite on May 19 at 10 a.m. ET, giving players an exclusive early look at 10 minutes of footage from Star Wars: The Mandalorian and Grogu before the film hits theaters on May 22, 2026. The island will also include a special message from director Jon Favreau. Welcome to Nevarro, Fortnite edition. The Watch Party Island is set on Nevarro, which is exactly the right choice. It is already one of The Mandalorian's most recognizable hubs: dusty streets, bounty jobs, shady corners, and the kind of town where someone is always either asking for help or making things worse. The island is being created by Fairview Portals and Beyond Creative, according to the official StarWars.com announcement. That means this is not just another loading-screen promo or a simple trailer drop. It is a dedicated Fortnite destination built around the movie. Players will be able to gather in-game, explore the island, and watch the preview together. It is basically a Star Wars fan screening, except everyone may also be dressed as a banana, a Sith Lord, or something that looks like it escaped from a cereal box. So, very Fortnite. Ten minutes is not a tiny tease. A 10-minute sneak peek is a serious preview. That is not "here is a 20-second clip of Grogu blinking near a cockpit." Ten minutes can show tone, action, character dynamics, new locations, and whether the movie feels like a true theatrical jump for Din Djarin and Grogu. The timing is also sharp. The Watch Party Island opens just three days before The Mandalorian and Grogu arrives in theaters, turning Fortnite into a final hype machine before opening weekend. And yes, this is very clearly part of the larger May Star Wars push inside Fortnite. Epic is also spotlighting new Star Wars islands, including Galactic Siege, Escape Vader, and Droid Tycoon, while Star Wars quests and cosmetics roll out throughout the month. Fortnite is becoming Star Wars' weirdest theater. This is the interesting part: Fortnite is not just advertising Star Wars anymore. It is hosting it. Between creator-made Star Wars games, official islands, watch parties, and crossover cosmetics, Fortnite is becoming a social platform where Star Wars can promote films, test interactive ideas, and gather fans in one place. That is bigger than a skin drop. For Star Wars gaming fans, it also blurs the line between event, game, trailer, and community hangout. Its complete list of all Star Wars games ever made tracks traditional releases, but Fortnite is increasingly becoming something harder to categorize: a playable Star Wars venue. The Mandalorian and Grogu Watch Party Island opens May 19. Nevarro is waiting. Please try not to sit behind the giant fish head. * Matt "ObiWaN" Hansen Matt "ObiWaN" Hansen is a veteran Star Wars writer and lore specialist with decades of firsthand experience spanning Star Wars books, films, television, and games. He has been actively involved in the Star Wars Galaxies community since its early days, where he helped build fan projects and online resources that served the wider player base. His coverage draws on long-term franchise knowledge, practical gaming experience, and deep roots in the Star Wars fan community.

Speed up Unreal Engine NNE inference with NVIDIA TensorRT for RTX runtime. Apr 30, 2026 Neural network techniques are increasingly used in computer graphics to boost image quality, improve performance, and streamline content creation. Approaches like super resolution, denoising, and neural rendering help real-time engines work more efficiently, offering new creative possibilities while keeping performance in mind. Unreal Engine 5 (UE5) has taken several steps in this direction with the introduction of the Neural Network Engine (NNE), which serves as an abstraction layer that unifies inference workloads across multiple backends. Developers can use various runtimes on a GPU or fall back to a CPU depending on available hardware for seamless integration of neural network features in real-time graphics workflows. This blog post covers the new plugin that adds NVIDIA TensorRT for RTX as an NNE runtime option (NNERuntimeTRT) for efficient inferencing on NVIDIA RTX GPUs. To show its benefits, I'll use a simplified UE project that runs a post-process AI model to highlight gains over other GPU runtimes, like DirectML. First, let's briefly discuss the different components involved in the project. TensorRT for RTX overview. TensorRT for RTX enables users to deploy AI models on RTX GPUs more efficiently. It uses a Just-In-Time (JIT) optimizer within the runtime to generate inference engines tailored to the user's GPU. This compilation occurs once on the user's machine and optimizes the model for their specific hardware. As a result, TensorRT for RTX can offer higher throughput compared to default execution providers. For example, throughput comparisons across various models show improvements when using TensorRT for RTX versus DirectML, as measured on an NVIDIA GeForce RTX 5090 GPU. TensorRT for RTX is only compatible with NVIDIA RTX GPUs, from the Turing generation (compute capability 7.5) up to the NVIDIA Blackwell generation (compute capability 10.0). Unreal Engine neural network engine overview. NNE supports multiple runtimes for invoking inferencing tasks and choosing between CPUs and GPUs. TensorRT for RTX is for GPUs and this overview focuses on NNE GPU runtimes. NNE can run inference on the GPU, either: * Synchronously from the CPU, requiring memory synchronization. * Asynchronously through the Render Dependency Graph (RDG), aligning with frame rendering. The synchronous method works well for editors and event-based inference tasks like LLMs, where copying data between host and device is not a concern. In contrast, RDG ties model evaluation to rendering resources, making it ideal for AI post-processing, upscaling, or denoising. The NNE TensorRT for RTX plugin supports both GPU and RDG methods, offering flexibility for various AI applications such as rendering, animation, language, and speech while maintaining strong performance on consumer-grade devices. The style transfer post-processing sample project. I built a basic UE5 project to test the NNE TensorRT for RTX plugin, which applies style transfer models during post-processing. For testing, I set up a simple level using a few basic primitives and a fixed camera to keep the visuals consistent while switching between DirectML and TensorRT, making it easier to compare both results and performance. Prerequisites. While the project is nearly ready for use, having experience with UE5, post-process materials, and engine source compilation is recommended. To run style transfer inference and manage rendering resources, you need an NNE implementation. UE5 offers this through the Neural Post-Processing plugin, which performs inference on the GPU through RDG. For this project, Andrew Ferguson'll utilize the NNERuntimeTRT RDG method. All that's required is to train or download an appropriate style model. Andrew Ferguson'll use a pre-trained one from the ONNX zoo. The project already includes an imported model (candy-9-720.uasset). Project setup. Although the NNE TensorRT for RTX plugin is compatible with the 5.7 binary engine release available from the launcher, the neural post-processing plugin contains a hard-coded list of runtimes within its neural profile asset. It's necessary to update its code to include the NNERuntimeTRT in the list of available runtimes for the neural profile asset. Get started: * Get the engine source from GitHub. If it is your first time accessing the engine code base, you need to link your GitHub account with your Epic account. Review this document, which explains the process for accessing the engine code base: * After initial engine setup, you should have a Visual Studio solution. Open the solution and locate the neuralprofile.h/cpp files under: Engine\Source\Runtime\Engine\Classes\Engine * In neuralprofile.h, add NNERuntimeTRT to ENeuralProfileRuntimeType (line 59) like so: | UNNERuntimeRDGTensorRT UMETA(DisplayName = "NNERuntimeTRT"), | | UNNERuntimeRDGTensorRT UMETA(DisplayName = "NNERuntimeTRT"), UENUM(BlueprintType) enum class ENeuralProfileRuntimeType: uint8 { NNERuntimeORTDml UMETA(DisplayName = "NNERuntimeORTDml"), /** Does not have full operator support*/ NNERuntimeRDGHlsl UMETA(DisplayName = "NNERuntimeRDGHlsl"), UNNERuntimeRDGTensorRT UMETA(DisplayName = "NNERuntimeTRT"), MAX UMETA(Hidden) }; | 5. In neuralprofile.cpp, find the GetNeuralProfileRuntimeName and add to the kRuntimeNames array (line 28): | ,TEXT("NNERuntimeTRT") | 6. The full kRuntimeNames array should be: | static const TCHAR* const kRuntimeNames = { TEXT("NNERuntimeORTDml"), TEXT("NNERuntimeRDGHlsl"), TEXT("NNERuntimeTRT") }; | * Get the plugin from Fab or the NVIDIA Developer page. * Unpack the plugin under the engine plugins folder in this path: ...\Engine\Plugins\Runtime\Nvidia It's also possible to place the plugin in the project, but for its case, it's simpler to keep it under the engine plugins. * Build the engine. Use these detailed instructions for compiling the engine. The first compilation takes time, so consider taking a break or grabbing a coffee. * Get started with the sample project. * Clone the sample project repository. * Load the project with the compiled engine and play the test level (LVL_PPStyleTest). Performance profiling. While playing the test level, activate the engine stats and alternate between TensorRT for RTX (TRT) and DirectML (DML) to assess performance improvements. For more comprehensive profiling, use Unreal Insights to capture frame information and breakdowns for both DML and TRT. On a system with NVIDIA GeForce RTX 5090 GPU at 1080p, in Unreal Insights, DML required 5.7 ms, whereas TRT completed in 3.8 ms - a 1.5x performance improvement. Using other style transfer models. You can use any style transfer models from the ONNX zoo or train your own. Note that ONNX zoo models have fixed dimensions of 1x3x224x224 for both input and output tensors. The neural process plugin enables tiling for small models to larger frame buffers. While this gives visually acceptable results, it's not recommended as it spawns multiple inference tasks per frame, causing frequent context switches between NVIDIA CUDA and graphics. To avoid the extra overhead of multiple context switches, change the model dimensions to 1x3x720x720 to run the inference without tiling while maintaining good visual quality. In the sample project repo, I've included a Python script that resizes the input and output tensor dimensions for style transfer ONNX models. About Homam Bahnassi Homam is a principal DevTech engineer with three decades of experience in games and engine development. He worked on several AAA titles and contributed to Unreal Engine enterprise features. Currently working at NVIDIA on the latest raytracing and AI technologies in Unreal.