Half the industry ships on Unity: most mobile, most indie, and plenty of mid-size PC. If you learned tech art in Unreal, the concepts transfer nearly one-to-one. Only the nouns and the scripting language change.
| You know it as (Unreal) | Unity calls it | Worth knowing |
|---|---|---|
| Actor + Components | GameObject + Components | Same idea; Unity is purer about it - everything is components |
| Blueprint class | Prefab (+ C# scripts) | Prefabs are data, not logic - behavior lives in attached scripts |
| Level / .umap | Scene | Additive scene loading ~= level streaming |
| Material instance | Material (asset) | Every Unity material is instance-like; the "master" is the shader itself |
| Material editor graph | Shader Graph | Same node vocabulary; your HLSL works in both (Custom Function node) |
| Content Browser / uassets | Project window / .meta files | The .meta sidecar files ARE the asset identity - never lose them (see gotchas) |
| Blueprint scripting | C# (MonoBehaviour) | No mainstream visual scripting in production; C# is unavoidable and fine |
| Data Asset / Data Table | ScriptableObject | The TA workhorse for tool configs and pipeline data |
| Editor Utility Widget / Python | Editor scripts (C#), [MenuItem] | Editor tooling is a first-class, genuinely pleasant workflow |
| Niagara | VFX Graph (HDRP/URP) or Shuriken (legacy) | VFX Graph is the Niagara-alike; Shuriken still ships most mobile FX |
Unity has three render pipelines, and everything visual depends on which one the project uses - shaders, materials, and half the tutorials on the internet are pipeline-specific. URP (Universal) is the modern default: scales from mobile to PC, where most new projects live. HDRP is the high-end path - closest to Unreal's out-of-box look, PC/console only. Built-in is the legacy pipeline still running many live games; its materials don't port forward automatically. First thing you do on joining any Unity project: find out the pipeline, because a shader authored for the wrong one renders magenta - Unity's version of a compile error, and your first debugging classic.
The honest adjustment: Unity's automation language is C#, not Python. The good news - editor tooling in C# is less ceremony than you fear, and your pipeline instincts port directly. The batch-renamer, in Unity dialect:
The Technical Artist
using UnityEditor;
using UnityEngine;
public static class BatchRename
{
[MenuItem("TA Tools/Rename Selected To Convention")]
static void Run()
{
foreach (var obj in Selection.objects)
{
string path = AssetDatabase.GetAssetPath(obj);
string name = obj.name.Replace(" ", "_");
if (!name.StartsWith("SM_")) name = "SM_" + name;
AssetDatabase.RenameAsset(path, name); // refs update, like UE
}
Debug.Log($"renamed {Selection.objects.Length} assets");
}
}Drop that in any folder named Editor/ and a menu item appears - no build step, no plugin registration. That folder-name-is-behavior convention is very Unity: learn the magic folders (Editor, Resources, StreamingAssets) early. Python does exist via packages for offline pipeline work, but in-editor, C# is the language of the land. Two weeks of discomfort; your Python brain maps almost everything.
Unity's import pipeline is scriptable per-event: hooks that run on every asset import, project-wide. This is where naming conventions, texture settings, and metadata get enforced automatically, which is the pattern the asset pipeline guide keeps pointing toward:
using UnityEditor;
class TAImportRules : AssetPostprocessor
{
void OnPreprocessTexture()
{
var importer = (TextureImporter)assetImporter;
string name = System.IO.Path.GetFileName(assetPath);
if (name.Contains("_N")) // normal maps: by convention
importer.textureType = TextureImporterType.NormalMap;
if (name.Contains("_ORM") || name.Contains("_Mask"))
importer.sRGBTexture = false; // data is linear. always.
}
void OnPreprocessModel()
{
var importer = (ModelImporter)assetImporter;
importer.useFileScale = true; // trust the FBX units
importer.importCameras = importer.importLights = false;
}
}Every texture named *_ORM imports linear, forever, for everyone, with no human remembering anything. If you write one piece of C# as a Unity TA, write this one.