How to Set Up Render Callbacks in Unreal Engine Movie Render Graph

Movie Render Graph (MRG) in Unreal Engine 5.4 provides a callback system for running additional tasks before and after render jobs. According to Epic Games’ official documentation, these tasks can be configured through an Execute Script Node added to the graph. This guide covers the basic setup for teams looking to prepare at the start of a render, inspect output data when a job finishes, or run tasks on a per-shot basis.

When are callbacks useful?

A callback is custom code that runs at a specific point in the render workflow. Job callbacks can run at the start and end of a job, while shot callbacks can run at the start and end of each shot. For example, you can inspect output data after a job completes or work with the file paths for a shot once it has finished.

The Execute Script Node in MRG lets you add callbacks to the graph configuration. A callback class is derived from MovieGraphScriptBase in Unreal’s Python API. The relevant functions are overridden with @unreal.ufunction(override=True). Once a callback class is registered, it can be selected from the menu in the Execute Script Node.

1. Set up the Movie Render Queue plugin and graph

First, in Unreal Editor, go to Edit > Plugins, enable the Movie Render Queue plugin in the Rendering section, and restart the editor. The project must contain a Level Sequence to render.

Movie Render Graph is accessed through Movie Render Queue. Epic’s documentation outlines the following steps:

1. Open the Movie Render Queue window via Window > Cinematics > Movie Render Queue.

2. Click the render button and select the relevant Level Sequence.

3. In the Settings column, open the Movie Render Graph (Beta) option from the Unsaved Config menu.

4. Create and name a Movie Render Graph from the Create New Asset section, then save it.

5. Open and edit the graph configuration you created from the Settings column.

Movie Render Queue (MRQ) and Movie Render Graph can be used together in an existing workflow. MRQ provides an interface for queuing jobs and batch rendering, while MRG configures render operations through a node-based graph.

2. Create a Python callback class

The example below shows job-start and job-finished callbacks. The on_job_finished call runs when a render job completes; this can include a cancellation as well as a successful finish. You can check whether the job succeeded using the success attribute in the result data.

import unreal

@unreal.uclass()
class CallbackOverrides(unreal.MovieGraphScriptBase):
    @unreal.ufunction(override=True)
    def on_job_start(self, in_job_copy):
        super().on_job_start(in_job_copy)
        unreal.log("Render işi başlıyor")

    @unreal.ufunction(override=True)
    def on_job_finished(self, in_job_copy, in_output_data):
        super().on_job_finished(in_job_copy, in_output_data)
        unreal.log("Render işi tamamlandı veya iptal edildi")

This example logs when a job starts and finishes. Before adding your own processing logic, it is important to understand when the callback runs and what data it receives. Job and graph configurations are passed to the callback as copies, so changes made inside the callback do not directly modify the original asset in the queue.

The class must be registered to appear in the Execute Script Node menu. In Epic’s example, the class is registered for the current session. If you want it to be available every time the editor starts, you can import the class from one of the /Content/Python/init_unreal.py files. This loads the class at editor startup.

3. Choose between job and shot callbacks

on_job_start runs when a render job begins, while on_job_finished runs at the end of the job. If a Level Sequence contains multiple shots, on_shot_start and on_shot_finished can be used for each shot individually. The shot-start callback runs before the shot is set up. The shot’s output data is passed to the shot-finished callback.

There are two ways to enable shot-level callbacks: check Flush Disk Writes Per Shot on the Global Output Settings Node in the graph, or override the is_per_shot_callback_needed function in the class so that it returns True. Don’t enable this option without considering the consequences: Epic notes that it can increase render time because the system waits for files to be written to disk.

What does this offer architecture and archviz workflows?

Visualization teams queuing multiple shots or scenes can use job- and shot-level callbacks to add repetitive tasks to the render workflow. Access to output data and file paths when a job completes provides a starting point for directing files generated by shots to a subsequent processing step, for example. However, the documentation does not specify a particular file-naming standard or a ready-made archviz automation; this logic needs to be developed for each project.

If you’re aiming to integrate with a render farm or another process, MRQ’s local and separate-process rendering options are also important. For rendering in a separate process, project changes must be saved. Test callbacks with a small job before using final delivery settings; in particular, check the effect of the per-shot disk-write option on render time and whether the class loads at editor startup.

Common mistakes

• Forgetting to restart the editor after enabling the Movie Render Queue plugin.

• Assuming shot callbacks will run automatically; the per-shot disk-write requirement must also be enabled.

• Interpreting job completion as meaning only a successful render. The callback can also be called if the job is canceled, so check the success status.

• Assuming that changes made to the copied job or graph configuration inside a callback will update the original asset in the queue.

• Overlooking that waiting for files to be written after each shot can increase render time.