What your assistant can work on

Find, import, rename, move and delete content, and get an accurate picture of what your project contains.

Create and change Blueprint classes: variables, functions, events and components, compiled and ready to test.

Fill in and update Data Table rows to your spec, and check what a table holds.

Set up Chooser Tables: columns, rows, conditions and the result each row picks.

Set up Enhanced Input: Input Actions and the mapping contexts that bind them to keys and buttons.

Create, import and configure textures, including render targets, texture arrays, compression and streaming.

Build and edit meshes: primitives, shape edits, UVs, collision and LODs.

Build a Static Mesh from a short .pwmodel text recipe, so the shape stays easy to tweak and rebuild.

Read or change any setting on any object, including ones no other area covers.

Change individual entries in array, map and set properties without rewriting the whole list.

Run any function an object exposes, for jobs no other area covers.

Check a Static Mesh's size, materials, LODs, collision and Nanite state.

Look back through a recorded play session to find out what went wrong. Needs your game set up to record.

Capture Unreal Insights traces and turn them into timing tables you can read.

Adjust scalability and console variables and take performance snapshots of the running session.

Work the editor itself: viewport camera, Play-In-Editor, console, undo and redo, saving and screenshots.

Run builds and automation tests, console commands and long jobs, and check the scene.

Run Python in the editor for anything no other area covers.

Check file status and history, revert files and mark new files for add.

Run your project's localization gather and compile steps and track them to the end.

Small editor helpers: cameras, playback speed, splines and post-process volumes.

Maintenance tasks for PinWright itself and its build tooling.

Build and restyle UMG Widget Blueprints: layout, styles, event bindings and animations.

Create, change and remove widgets on screen while the game is running.

Play the game with real input, read what is on screen and check that it shows what it should.

Play sounds and adjust the mix in the running world, and author sound assets.

Place, move, tag and attach actors in the level, and edit their components.

Open, create, save and edit maps, including streaming, lighting and navigation builds.

Work with World Partition: load cells, manage Data Layers and check partitioned levels.

Place and set up volumes: blocking, trigger, post-process, audio, navigation, lighting and kill-Z.

Create and shape splines, and scatter meshes along them.

Set up foliage types, paint foliage, run procedural foliage and edit instances.

Create and sculpt terrain, assign landscape materials, and add grass.

Add rivers, lakes, oceans and water zones. Needs the Water plugin.

Set up sky, fog, time of day and other ambience for a level.

Set up the nav mesh, agent settings, nav areas, modifiers and nav links.

Measure distances, find free space and place things on surfaces, then check they landed where they should.

Create materials and material instances, set parameters and edit material graphs as readable text.

Build and adjust Niagara effects: systems, emitters, modules and parameters.

Set up lights, sky light, shadows, global illumination and volumetric fog, and build lighting.

Tune the look: color grading, bloom, Lumen and anti-aliasing.

Change renderer project settings that stay after an editor restart.

Take exact-size screenshots of asset previews, the level viewport or render targets.

Line a reference image up with your world, mark it up and compare two versions.

Frame an actor in the viewport from a chosen angle and capture it, or grab a standard set of views around it.

Show temporary debug shapes and preview lights in the running world.

Set up and run Movie Render Queue jobs from a Level Sequence.

Work with Animation Blueprints, blend spaces, IK, retargeting and montages.

Write or read back Animation Blueprint graphs as readable text you can review.

Write or read back Control Rig graphs and rig hierarchies as readable text.

Work on skeletons: bones, sockets, morph targets, skin weights, physics assets and cloth.

Set up the Pose Search schemas and databases that Motion Matching uses.

Set up physics assets, ragdolls, and vehicle wheels and suspension.

Build Level Sequences for cinematics: bindings, tracks and keyframes, and play them back in the editor.

Set up AI: perception, blackboards, behavior trees, EQS, Mass, Smart Objects and StateTree.

Build Behavior Tree graphs and read them back as text you can review.

Build Environment Query System assets: generators, tests and contexts.

Build StateTree assets: evaluators, tasks, conditions and transitions.

Set up the Gameplay Ability System: abilities, effects, cues, attribute sets and the ability component.

Add gameplay tags and build tag queries.

Set up a character's movement, capsule, mesh, camera and footsteps.

Set up game modes, pawns, game state, controllers, respawning, scoring, teams and rounds.

See which Game Feature plugins are installed, registered, loaded or active.

Add interactable things to your game: prompts, doors, switches and loot.

Set up local players, split-screen, LAN host and join, and voice chat.

Set up replication, RPC functions, relevance, network roles, prediction and network settings.

Set up Chaos Vehicle wheel and suspension assets.

Build PCG graphs for procedural generation.