What Coding Language Does Unreal Engine Use? A Complete Guide

Fortnite, one of the biggest games on the planet, runs on the same engine that powers Hollywood films, car design studios, and architectural walkthroughs. That engine is Unreal Engine, and behind all that visual magic sits code. So when people ask what coding language does Unreal Engine use, they usually expect a one-word answer. The reality is more interesting: Unreal gives you several ways to program, and each one fits a different kind of creator.

This matters because picking the wrong path can cost you months. Some developers spend a year fighting C++ compiler errors when a visual scripting system would have shipped their prototype in weeks. Others build an entire game in Blueprints and then hit a performance wall they cannot climb. In this guide, you will learn exactly which languages Unreal Engine supports, how C++ and Blueprints actually work together, where Verse and Python fit in, what hardware and tools you need, how long each option takes to learn, and which mistakes trip up beginners most often. By the end, you will know precisely which language to start with for your goals.

The Core Answer: C++ Is Unreal Engine’s Native Language

Unreal Engine is written in C++, and C++ is the primary programming language you use to build games and applications with it, though Epic Games also provides Blueprints visual scripting as a full-featured alternative that requires no traditional code. The entire engine source code, all 3 million-plus lines of it, sits in a public GitHub repository written in C++. When you write gameplay code in Unreal, you write C++ that compiles alongside the engine itself.

But Unreal’s C++ is not quite the same as the C++ you might learn from a general programming textbook. Epic layers a system of macros and reflection on top of standard C++ to add features the language does not have natively. You will see keywords like UCLASS, UPROPERTY, UFUNCTION, and USTRUCT scattered through Unreal code. These macros feed the Unreal Header Tool, which generates extra code before compilation. That generated code powers garbage collection, serialization, network replication, and the ability for Blueprints to see and call your C++ functions.

Because of this, many developers describe Unreal C++ as its own dialect. You rarely manage memory manually the way you would in raw C++. Instead, objects that inherit from UObject get tracked and cleaned up by Unreal’s garbage collector. You also use Epic’s own container types, like TArray instead of std::vector and FString instead of std::string. This makes Unreal C++ friendlier than people expect, but it also means generic C++ tutorials only take you part of the way.

Here is a quick look at the languages and scripting systems that officially touch Unreal Engine:

C++ – the native language of the engine and the language of all gameplay framework classes
Blueprints – a node-based visual scripting system that compiles to bytecode and runs on a virtual machine inside the engine
Verse – Epic’s newer programming language, currently used in Unreal Editor for Fortnite and rolling out more broadly
Python – an editor scripting language for automation, asset pipelines, and tool building, not for shipping gameplay
C# – used by UnrealBuildTool and UnrealAutomationTool for build scripts, not for gameplay
HLSL – the shader language behind custom material nodes and global shaders

How Blueprints Work and Why Epic Built Them

Blueprints let you build complete game logic by dragging nodes onto a graph and connecting them with wires. Each node represents a function, a variable, an event, or a flow-control operation. You connect an execution pin from one node to the next to define order, and you connect data pins to pass values around. If you have ever used a flowchart, the concept will click within an hour.

Epic did not build Blueprints as a toy. Blueprints are a real programming system with variables, arrays, maps, structs, enums, interfaces, inheritance, loops, and custom events. When you hit compile, the editor turns your graph into bytecode that a virtual machine executes at runtime. Designers, artists, and technical directors use Blueprints daily on shipped commercial games, and entire titles have launched with Blueprint-only gameplay code.

What Blueprints Do Really Well

Blueprints shine when you need to iterate fast. You change a node, hit compile, and see the result in about a second without leaving the editor. Compare that to C++, where a change to a header file can trigger a rebuild that takes several minutes. Blueprints also give you live debugging: you can watch execution wires light up in real time while the game runs, which makes tracking down logic bugs far easier than reading a stack trace.

Where Blueprints Struggle

Blueprint bytecode runs slower than compiled C++. Community benchmarks commonly put Blueprint execution somewhere in the range of 5 to 10 times slower for tight loops and heavy math, though the gap shrinks a lot in real gameplay because most expensive work happens inside native engine functions the Blueprint simply calls. The bigger practical problem is maintainability. Large Blueprint graphs turn into what developers call spaghetti, and version control tools cannot show meaningful diffs on binary Blueprint assets, which makes team merges painful.

Factor	Blueprints	C++
Learning curve	Days to weeks	Months
Iteration speed	Instant compile	Seconds to minutes
Runtime performance	Good for most logic	Fastest available
Version control diffs	Binary, hard to merge	Plain text, easy to merge
Engine source access	Only exposed functions	Everything
Debugging	Visual, live wires	Breakpoints in IDE
Best user	Designers, artists, solo devs	Engineers, larger teams

The Hybrid Workflow Most Professional Studios Actually Use

Here is the part beginners often miss: the question is rarely C++ or Blueprints. Nearly every professional Unreal team uses both, and they use them in a specific pattern. Programmers write base classes in C++, expose variables and functions to the editor with UPROPERTY and UFUNCTION macros, and then designers create Blueprint children of those C++ classes to tune values and assemble behavior.

Picture a shooter. A programmer writes a C++ class called AWeaponBase that handles the firing logic, ammo math, damage application, and network replication. She marks damage, fire rate, magazine size, muzzle flash effect, and reload sound as EditAnywhere UPROPERTYs. A designer then creates BP_AssaultRifle, BP_Shotgun, and BP_SniperRifle as Blueprint children. Each one gets different numbers, different meshes, and different sounds without a single line of code or a single recompile. Adding a new weapon takes fifteen minutes instead of a day.

This split follows a simple rule of thumb that has held up across thousands of projects:

Put systems, math-heavy code, and anything that runs every frame in C++.
Put content, tuning values, and one-off level logic in Blueprints.
Expose C++ functionality to Blueprints deliberately, not accidentally.
Move Blueprint logic down to C++ when a graph grows past roughly 40 or 50 nodes or shows up in the profiler.
Keep the Blueprint layer thin so a graph mostly calls named C++ functions rather than doing raw work itself.

Epic’s own sample projects follow this exact pattern. Open the Third Person template with C++ enabled and you will find a C++ character class with a Blueprint child that holds the mesh, animation blueprint, and camera settings. Lyra, Epic’s large-scale sample shooter, pushes the idea further with a modular C++ backbone and hundreds of Blueprint and data assets layered on top.

Getting Started With Unreal C++: Tools, Setup, and First Steps

Before you write a line of C++, you need a compiler and an IDE. Unreal does not ship with one. On Windows, you install Visual Studio Community with the “Game development with C++” workload and the Unreal Engine installer component. On macOS, you use Xcode. On Linux, you use a compatible toolchain plus an editor like Rider or VS Code. JetBrains Rider has become a favorite in the Unreal community because it understands Unreal’s macros, reflection system, and Blueprint references far better than a plain code editor does.

Creating Your First C++ Class

You do not create C++ files by hand. Inside the Unreal Editor, you use Tools then New C++ Class, pick a parent class such as Actor, Pawn, Character, or ActorComponent, name it, and let the editor generate the header and source files with the right boilerplate. Then you switch to your IDE, write your logic, and compile. The editor supports Live Coding, which lets you recompile function bodies while the editor stays open, saving enormous amounts of time.

The Vocabulary You Will Meet Immediately

UObject – the base class for almost everything Unreal manages, including garbage collection and reflection
AActor – anything that can be placed in a level, prefixed with A
UActorComponent – reusable pieces of behavior you attach to actors
TArray, TMap, TSet – Unreal’s container types, used instead of the C++ standard library versions
FString, FName, FText – three different string types for general text, fast identifiers, and localized display text
TSubclassOf – a type-safe way to reference a class rather than an instance
UPROPERTY – the macro that exposes a variable to the editor, Blueprints, saving, and networking
BlueprintCallable and BlueprintImplementableEvent – the two main ways C++ and Blueprints talk to each other

A practical first project looks like this: create a C++ Actor that rotates, expose a float called RotationSpeed as a UPROPERTY with EditAnywhere, drop it into a level, and change the speed in the Details panel while the game runs. That single exercise teaches you class creation, the tick function, macros, and the C++ to editor connection all at once. Most people finish it in under an hour.

Verse: Epic’s New Language and What It Means for the Future

Epic Games introduced Verse as a brand-new programming language designed for what the company calls the metaverse: large, persistent, multi-author worlds where code written by different people has to run safely side by side. Verse first appeared publicly in Unreal Editor for Fortnite, where creators use it to script islands and game modes.

Verse is not a replacement for C++, at least not yet. It is a textual language with an unusual mix of features. It uses a functional-logic style, has strong static typing, treats failure as a first-class concept rather than an exception, and includes structured concurrency built directly into the language so you can write time-based gameplay logic without callback spaghetti. Epic’s stated long-term goal is to bring Verse into the main Unreal Engine as a scripting layer that sits between Blueprints and C++.

Should You Learn Verse Right Now?

The honest answer depends on your goal. If you want to publish Fortnite creative experiences and earn money from Epic’s creator payouts, Verse is the language to learn today. If you want to build a standalone commercial game, ship on Steam or consoles, or get hired at a studio, C++ and Blueprints remain the practical choices. Verse is worth watching closely, and its concurrency features solve real problems, but the job market and tutorial ecosystem around it are still small compared to C++.

Here is a simple way to compare the three main paths inside the Unreal universe:

Language	Main use today	Runs where	Maturity
C++	Full game and engine development	All platforms, compiled native	Fully mature
Blueprints	Gameplay, content, prototyping	All platforms, VM bytecode	Fully mature
Verse	Fortnite islands, future scripting	UEFN, expanding	Actively evolving

Python, C#, HLSL, and the Other Languages Around the Engine

Plenty of people search for whether Unreal supports Python or C#, usually because they know those languages already. Both exist in the Unreal ecosystem, but neither one does what you might hope.

Python for Editor Automation

Unreal ships with a Python plugin that gives you scripting access to the editor itself. Studios use it constantly for pipeline work: batch importing hundreds of assets, renaming files to match naming conventions, generating level layouts from spreadsheets, running automated tests, and building custom editor tools. Python does not run in a packaged game. When you ship your project, the Python code stays behind. So Python is a tools language, not a gameplay language.

C# in the Build System

UnrealBuildTool, the system that decides what to compile and how, is written in C#. Your project’s Build.cs and Target.cs files are C# files where you list module dependencies and set compilation options. You will edit them regularly, for example when you add the UMG or AIModule dependency. But you cannot write gameplay in C# with stock Unreal. Third-party plugins have tried to add C# scripting over the years, and some work reasonably well, but none are officially supported, and betting a long project on one carries real risk.

HLSL for Shaders

Unreal’s Material Editor is itself a visual node system, similar in spirit to Blueprints. When you need something the nodes cannot express, you drop in a Custom node and write HLSL directly. Advanced graphics programmers go further and write global shaders as .usf files inside the engine’s shader directory. If you care about rendering, HLSL eventually becomes unavoidable.

Other Odds and Ends

Lua – not built in, but several community plugins add Lua scripting for teams that want hot-reloadable logic
JavaScript and TypeScript – available through third-party plugins, occasionally used for UI-heavy tools
Angelscript – an unofficial engine fork maintained by the studio Hazelight, used to ship games like It Takes Two, offering a scripting language with C++-like syntax and instant hot reload
Rust and Go – no official support, though people have bound libraries through C++ wrappers

Common Misconceptions That Slow Beginners Down

The Unreal community repeats certain myths so often that they feel like facts. Clearing them up early saves a lot of wasted effort.

Myth one: you must know C++ before you can touch Unreal. You do not. Thousands of people build playable games with zero C++ using only Blueprints, materials, and the engine’s built-in systems. Starting in Blueprints teaches you the engine’s architecture, the gameplay framework, and the mental model of how actors, components, and events fit together. That knowledge transfers directly when you eventually add C++.

Myth two: Blueprints are too slow for real games. The slowdown is real but usually irrelevant. If a Blueprint node calls a C++ engine function like LineTraceByChannel, the trace runs at full native speed. The overhead only lives in the glue between nodes. Problems appear when you loop over ten thousand items every frame inside a graph, and the fix is to move that one loop to C++, not to abandon Blueprints entirely.

Myth three: Unreal C++ is the same as the C++ from a college course. It shares the syntax, but the idioms differ enough that people with strong general C++ backgrounds still need weeks to feel comfortable. You will use Unreal’s smart pointers, its containers, its logging macros, and its module system rather than the standard library conventions you may be used to.

Myth four: you have to pick one and stick with it forever. Migrating logic between Blueprints and C++ is normal and expected. A common workflow is to prototype a feature entirely in Blueprints, prove the design is fun, then rewrite the core in C++ and keep a thin Blueprint layer for tuning. Epic even provides a Blueprint Nativization option in older versions and continues to improve the C++ and Blueprint boundary.

One more practical point worth stating plainly: the biggest cause of failed Unreal projects is scope, not language choice. A tight, small game finished in Blueprints beats an ambitious open-world project abandoned in C++ every single time.

How Long It Takes to Learn and the Best Resources to Use

Time to competence varies wildly with background, but the community sees fairly consistent patterns. Someone with no programming experience typically becomes productive in Blueprints within two to four weeks of steady practice, meaning they can build a working character controller, a pickup system, and a simple UI. Reaching comfortable Unreal C++ from a total beginner start usually takes six months to a year. A developer who already knows C++ from another field often needs two to three months to learn Unreal’s specific patterns.

A Learning Path That Works

Complete the Third Person template tutorial and understand every default asset in it.
Build one tiny finished game in pure Blueprints, such as a collect-the-coins platformer, and actually package it.
Learn the gameplay framework properly: GameMode, GameState, PlayerController, Pawn, Character, PlayerState, and HUD.
Install Visual Studio or Rider and convert one Blueprint from your small game into a C++ class.
Learn UPROPERTY and UFUNCTION specifiers deeply, since they control everything about how C++ meets the editor.
Study replication and networking, which is where C++ becomes hard to avoid.
Read Epic’s Lyra sample project source to see professional structure.

Resources Worth Your Time

Epic Developer Community and official documentation – free courses, the API reference, and the full C++ class hierarchy
Unreal Engine GitHub source – free after linking your Epic and GitHub accounts, and reading engine source is the single fastest way to learn
Lyra Starter Game – a full modern shooter sample showing production-grade C++ and Blueprint structure
Unreal Slackers Discord – a large active community where specific questions get real answers
Tom Looman’s blog and course – widely recommended for Unreal C++ specifically
The Unreal Engine forums and AnswerHub archives – many odd errors have already been solved there

Consider a realistic scenario. A hobbyist with a full-time job spends five hours a week. In month one, she finishes the templates and understands actors and components. By month three, she has a small Blueprint game running with a menu and save system. By month six, she has moved her inventory system into C++ because the Blueprint graph became unreadable. By month twelve, she writes new features in C++ first and uses Blueprints only for content. That pace is normal and healthy.

Unreal Versus Unity and Godot: A Language Comparison

Understanding Unreal’s language choices gets easier when you compare them with the other major engines, since the trade-offs become obvious.

Unity uses C#, a managed language with garbage collection and a gentler learning curve than C++. Many people find C# faster to pick up, and Unity’s iteration loop is quick. The trade-off is that you cannot see or modify most of Unity’s engine internals, and squeezing out maximum performance requires special systems like the job system and Burst compiler. Godot offers GDScript, a Python-like language built specifically for the engine, plus C# and the option to write C++ modules. GDScript is arguably the easiest of all to learn, and Godot’s small size makes it fast to start.

Engine	Primary language	Visual scripting	Engine source access
Unreal Engine	C++	Blueprints, fully featured	Full source on GitHub
Unity	C#	Third-party and limited built-in options	Reference only, paid full access
Godot	GDScript and C#	Removed from core in newer versions	Fully open source

What makes Unreal genuinely different is the combination of full C++ source access and a first-class visual scripting system. You can go as low-level as rewriting the renderer or as high-level as never writing text code at all, inside the same project. No other mainstream engine offers that range. That is also why Unreal dominates in film, automotive visualization, architecture, and broadcast, where teams often include artists who need power without programming and engineers who need to modify the engine itself.

If you are choosing an engine based purely on language comfort, here is the short version: pick Unity if you love C# and managed languages, pick Godot if you want the simplest possible entry, and pick Unreal if you want top-tier rendering out of the box plus the freedom to work visually or dive into native code. Skills transfer between all three more than beginners expect, because the underlying concepts of components, transforms, delta time, and game loops stay the same everywhere.

Where Unreal Programming Is Heading

Several shifts are reshaping how people write code for Unreal, and knowing them helps you invest your learning time wisely.

First, Verse keeps expanding. Epic has been clear that Verse is meant to eventually reach the main engine, giving developers a modern textual scripting option that avoids both Blueprint graph clutter and C++ compile times. If that lands well, the classic two-language split could become a three-language ecosystem.

Second, data-driven design keeps growing. More studios push game behavior into Data Assets, Data Tables, and Gameplay Ability System configurations instead of hard-coding it. That means less raw code and more structured content, and it rewards developers who understand architecture over developers who just know syntax.

Third, AI assistance changes the day-to-day work. Code assistants now handle a lot of Unreal boilerplate, macro syntax, and API lookups. This lowers the barrier to C++ noticeably, but it raises the value of understanding the engine’s systems, because you still have to know what to ask for and whether the answer is correct.

Fourth, the gameplay framework itself keeps modernizing. Enhanced Input replaced the old input system, the Gameplay Ability System became the standard for complex abilities, Mass Entity brought data-oriented design for huge crowds, and StateTree offers a new way to build behavior. Each of these shifts what “knowing Unreal programming” actually means. The syntax matters less every year; the systems matter more.

Learn the gameplay framework deeply, since it outlasts any single language
Get comfortable reading engine source, because documentation always lags behind
Practice moving logic between Blueprints and C++ so neither one traps you
Watch Verse releases if you plan to work in the Fortnite ecosystem
Build small, finish projects, and let real problems teach you what to study next

So what coding language does Unreal Engine use? C++ sits at the heart of it, powering the engine itself and every gameplay class you will ever inherit from. Blueprints ride on top as a genuine visual programming language that ships in real commercial games. Verse is emerging as Epic’s forward-looking option, Python handles editor automation, C# drives the build system, and HLSL handles shaders. Most successful teams do not choose one; they combine C++ for systems with Blueprints for content, and that hybrid approach has produced some of the biggest games and films of the last decade.

The best move you can make right now is to stop worrying about the perfect language and start building something small. Open a template, wire up a few Blueprint nodes, and get a character moving. When a graph gets messy or the profiler flags a bottleneck, that is your signal to learn the C++ side. Every skilled Unreal developer you admire walked that same path, one finished feature at a time, and the tools available today make that journey shorter and friendlier than it has ever been.