Unity Game Engine in 2026: Unity 6, C# Scripting, C++ Plugins and Pricing

Unity is the engine behind a huge share of the games people actually play: Pokémon GO, Among Us, Monument Valley 2, Genshin Impact, Hollow Knight: Silksong. More than 8,500 Unity-made games landed on Steam in each of 2024 and 2025. If you’re choosing an engine, hiring for one, or just trying to understand what Unity is in 2026, the engine is in a very different place from where it stood two or three years ago: a new major version line (Unity 6), a pricing model that went through a public crisis and back, and a scripting runtime in the middle of its biggest rebuild in a decade.

This guide answers the questions searchers keep asking and other pages answer badly. Is Unity a C++ engine? (Its core is; your game code isn’t.) Can you write C++ for Unity? (Yes, as native plugins, and there’s a working example below.) What does it cost now, and is it still worth picking? Every version date and price here was checked against Unity’s own release and pricing pages in October 2026.

What Is Unity?

Unity is a cross-platform game engine made by Unity Technologies, first released in June 2005 as a Mac OS X tool and now used for 2D, 3D, mobile, console, web and XR games. Its runtime is written in C++, while developers script games in C#. The current generation is Unity 6; Unity 6.3 is the latest long-term support (LTS) release.

Unity Technologies began in Copenhagen in August 2004 as Over the Edge Entertainment, founded by David Helgason, Nicholas Francis and Joachim Ante. Its first game, GooBall, sold poorly, but the tools built to make it became the product. The company took the Unity name in 2007, the same year the iPhone arrived. Unity was one of the first engines to support Apple’s phone fully, and that early bet is a big reason it became the default engine for mobile games.

Unity Version History: From 1.0 to Unity 6

Unity’s numbering has changed twice, which confuses anyone reading old tutorials. There were numbered majors up to Unity 5, then year-based releases (Unity 2017 through Unity 2023), then a return to plain numbers with Unity 6.

How Unity 6 releases work

From Unity 6 onward there are two release types. LTS releases come out once a year and get two years of bug fixes and platform updates (three for Enterprise and Industry subscribers). Update releases ship several times a year with new features and are supported until the next release lands. Unity recommends LTS for live-service games and for teams about to lock production. Update releases suit projects that need the newest features.

One practical note for October 2026: Unity 6.0 LTS reached the end of standard support on October 16, 2026. Teams still on 6.0 should plan a move to 6.3 LTS, or wait for 6.7 LTS if their schedule allows.

Does Unity Use C++ or C#?

Both, and the split is the most misunderstood thing about Unity. Many “C++ game engine” lists include Unity, and older tutorials refer to Unity “JavaScript”, so a lot of newcomers assume they’ll be writing C++ or JavaScript. Neither is true for everyday Unity work.

• The engine itself is C++. Rendering, physics integration, memory management and the platform layers are a large native C++ codebase. Unity’s own engineers describe it as a very large C++ codebase built around assumptions from the Mono .NET runtime.
• Your game code is C#. Every gameplay script, editor tool and component you write in Unity is C#. The C# API (MonoBehaviour, GameObject, Transform and so on) is how you talk to the C++ core.
• IL2CPP turns your C# into C++ at build time. On platforms that don’t allow just-in-time compilation (iOS, consoles, WebGL), Unity’s IL2CPP backend converts your compiled C# into C++ and then into native code. You still write C#; the C++ is generated.
• You can add your own C++ through native plugins. This is the real answer to “can I use C++ in Unity?”, covered in the next section.
• UnityScript and Boo are gone. Unity once shipped a JavaScript-like language (UnityScript) and a Python-like one (Boo). Boo was dropped from the docs in 2014, UnityScript was deprecated starting in 2017, and Unity 2019.1 removed the compiler for both. Fewer than 4% of Unity 5.6 projects used UnityScript as their main language by then.

So when someone asks whether Unity is a “C++ game engine”, the accurate answer is: Unity is built in C++ and scripted in C#. If you want an engine where your own gameplay code is C++, that’s Unreal Engine or an engine like Godot with its C++ extension system.

How to Use C++ in Unity: Native Plugins

A native plugin is a shared library (.dll on Windows, .so on Linux and Android, .dylib or a bundle on macOS) that Unity loads at runtime. C# calls into it with P/Invoke. Teams use plugins to reuse an existing C++ library, to speed up a hot loop, or to issue graphics commands directly on Unity’s render thread.

Unity ships the plugin headers with every Editor install, in a PluginAPI folder (<UnityInstallPath>\Editor\Data\PluginAPI on Windows; inside the app bundle under Contents/PluginAPI on macOS). The main header is IUnityInterface.h; graphics access lives in IUnityGraphics.h. For a fuller example that renders through Direct3D 11 and 12, Vulkan and Metal, see Unity’s official NativeRenderingPlugin sample on GitHub.

The plugin below does three things: it exposes a plain math function to C#, it tracks the graphics device through Unity’s device-event callback, and it gives Unity a function to call on the render thread.

// NativeDemo.cpp - a minimal Unity native plugin (C++17)
// Headers: copy PluginAPI/*.h from your Unity Editor install
// (Editor/Data/PluginAPI) into a Unity/ folder next to this file.
#include "Unity/IUnityInterface.h"
#include "Unity/IUnityGraphics.h"
#include <cmath>

static IUnityInterfaces* s_Interfaces = nullptr;
static IUnityGraphics*   s_Graphics   = nullptr;
static UnityGfxRenderer  s_Renderer   = kUnityGfxRendererNull;
static int               s_FrameCount = 0;

// 1) Plain function, called from C# through P/Invoke.
extern "C" float UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API
DistanceSquared(float x1, float y1, float x2, float y2)
{
    const float dx = x2 - x1, dy = y2 - y1;
    return dx * dx + dy * dy;
}

extern "C" int UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API
GetRenderEventCount() { return s_FrameCount; }

// 2) Graphics device lifetime events.
static void UNITY_INTERFACE_API OnGraphicsDeviceEvent(UnityGfxDeviceEventType type)
{
    if (type == kUnityGfxDeviceEventInitialize)
        s_Renderer = s_Graphics->GetRenderer();   // e.g. D3D11, Vulkan, Metal
    else if (type == kUnityGfxDeviceEventShutdown)
        s_Renderer = kUnityGfxRendererNull;
}

// 3) Unity calls these when the plugin DLL is loaded and unloaded.
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API
UnityPluginLoad(IUnityInterfaces* unityInterfaces)
{
    s_Interfaces = unityInterfaces;
    s_Graphics   = s_Interfaces->Get<IUnityGraphics>();
    s_Graphics->RegisterDeviceEventCallback(OnGraphicsDeviceEvent);
    // The device may already exist if the plugin loads late.
    OnGraphicsDeviceEvent(kUnityGfxDeviceEventInitialize);
}

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginUnload()
{
    if (s_Graphics)
        s_Graphics->UnregisterDeviceEventCallback(OnGraphicsDeviceEvent);
}

// 4) Runs on Unity's render thread when C# calls GL.IssuePluginEvent.
static void UNITY_INTERFACE_API OnRenderEvent(int eventId)
{
    if (s_Renderer == kUnityGfxRendererNull) return;
    ++s_FrameCount;   // issue native GPU commands for s_Renderer here
    (void)eventId;
}

extern "C" UnityRenderingEvent UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API
GetRenderEventFunc() { return OnRenderEvent; }

Build it as a shared library, for example g++ -std=c++17 -fPIC -shared -o libNativeDemo.so NativeDemo.cpp on Linux, or a DLL project in Visual Studio on Windows. Drop the result into your project’s Assets/Plugins folder. The C# side looks like this:

using System;
using System.Runtime.InteropServices;
using UnityEngine;

public class NativeDemo : MonoBehaviour
{
    // "NativeDemo" matches libNativeDemo.so / NativeDemo.dll.
    // On iOS and WebGL, statically linked plugins use "__Internal" instead.
    [DllImport("NativeDemo")] static extern float DistanceSquared(float x1, float y1, float x2, float y2);
    [DllImport("NativeDemo")] static extern IntPtr GetRenderEventFunc();
    [DllImport("NativeDemo")] static extern int GetRenderEventCount();

    void Start()
    {
        Debug.Log(DistanceSquared(0, 0, 3, 4));   // 25
    }

    void Update()
    {
        // Queue OnRenderEvent(1) to run on Unity's render thread.
        GL.IssuePluginEvent(GetRenderEventFunc(), 1);
    }
}

Three rules save most first-time plugin authors a day of debugging:

1. Export with extern "C" and Unity’s macros. UNITY_INTERFACE_EXPORT and UNITY_INTERFACE_API set the right visibility and calling convention (__stdcall on 32-bit Windows). Without extern "C", C++ name mangling hides your function from DllImport.
2. Never touch the graphics device from the main thread. GPU work belongs in the render-event callback, which Unity runs on its render thread. That’s why GL.IssuePluginEvent exists.
3. Expect a late load. A plugin can load after the graphics device already exists, so call your own initialize handler from UnityPluginLoad, as the example does.

Key Features of Unity 6

Rendering. Unity has two Scriptable Render Pipelines: URP (Universal Render Pipeline) for everything from phones to PCs, and HDRP (High Definition Render Pipeline) for high-end PC and console visuals. The older Built-In Render Pipeline was officially deprecated in Unity 6.5 (June 2026). New projects should start on URP. Unity 6 also added the GPU Resident Drawer and Render Graph for URP, which move work from the CPU to the GPU; Unity claims up to four times better CPU performance in suitable scenes.

Physics. Unity uses NVIDIA PhysX for 3D and Box2D for 2D, with an updated Box2D backend in the 6.7 beta. Havok Physics for Unity is no longer bundled with paid plans from Unity 6.3.

Data-oriented stack (DOTS/ECS). The Entity Component System lets you lay out game data for cache-friendly, multi-threaded processing, with the Burst compiler turning a subset of C# into highly optimized native code. Unity is now working to unify ECS with the classic GameObject model.

Animation, audio and navigation. Mecanim handles state-machine character animation and retargeting between rigs. The audio system supports 3D spatial sound and mixer effects. The AI Navigation package bakes navigation meshes from scene geometry and supports links for jumps and doors, plus moving obstacles.

UI. UI Toolkit, a retained-mode system styled with a CSS-like language, is Unity’s long-term direction. The older uGUI is still widely used and still getting fixes. The 6.7 beta adds grid layout, z-index and gradients to UI Toolkit.

Multiplayer and web. Unity 6 introduced a Multiplayer Center that wires up networking packages. It also added mobile-browser builds. In Unity 6.6, WebGPU became production-ready for web builds, with WebGL 2 still the default.

Platforms. Unity builds to Windows, macOS, Linux, iOS, Android, the web, PlayStation, Xbox, Nintendo Switch and Switch 2, and XR devices including Meta Quest and Apple Vision Pro. Console and Vision Pro publishing requires a Pro or higher subscription.

What’s Next: CoreCLR and Modern C#

The biggest change in Unity’s near future isn’t a feature; it’s the scripting runtime. Unity has run C# on its own fork of Mono for its whole life, which is why Unity developers have lagged the wider .NET world on language versions and garbage-collector improvements.

Unity’s published plan replaces Mono with CoreCLR, Microsoft’s modern .NET runtime:

• Unity 6.7 LTS (planned for late 2026) is the last release built on Mono. It ships an experimental CoreCLR desktop player, still limited to .NET Standard 2.1 and C# 9.
• Unity 7, announced at Unite Seoul in July 2026, brings CoreCLR with .NET 10 and C# 14, plus a code-reload model that reloads only what changed. Unity calls it a direct continuation of Unity 6 with no breaking changes. A preview is due in December 2026, and the full release is targeted for Q1 2027 (Unite Seoul 2026 keynote recap).
• IL2CPP stays. CoreCLR’s own ahead-of-time compiler doesn’t cover all of Unity’s target platforms, so IL2CPP remains the route to iOS, consoles and the web.

Treat the Q1 2027 date as a target, not a promise. Unity has paused work on some new animation and world-building tools to concentrate on this migration, which signals how much it is betting on it.

Unity Licensing and Pricing in 2026

Unity charges per seat (per developer), not a royalty on your game’s revenue. The current plans:

Pro and Enterprise prices rose 5% on January 12, 2026; existing subscribers pay the new rate from their first renewal after that date. Unity also lifted seat limits on its cloud version control in 2026.

The Runtime Fee, and why it’s gone

In September 2023, Unity announced a Runtime Fee: a charge per game install once a title crossed revenue and install thresholds, applying even to games already released. The developer backlash was immediate and severe, and Unity partly walked it back within weeks. CEO John Riccitiello retired soon after. Some studios left: Mega Crit moved Slay the Spire 2 to Godot, citing the fee among its reasons.

On September 12, 2024, new CEO Matt Bromberg cancelled the Runtime Fee for games customers outright and returned to seat-based pricing. The Personal tier’s ceiling doubled from $100,000 to $200,000, and Pro rose 8% to $2,200 (now $2,310). Bromberg later told The Verge that the company had been practically at war with its customers. Unity has since committed to predictable annual price adjustments rather than new fee types.

Unity vs Unreal vs Godot

The three engines most people compare cost money in completely different ways, and that difference drives more decisions than any feature list.

As a rough rule: a mobile game, a 2D game, or anything targeting Quest and Vision Pro from one codebase points to Unity. A photoreal 3D game with a team fluent in C++ points to Unreal; see our Unreal Engine guide and its Unreal vs Unity breakdown. If you want an engine you own completely, down to the source, look at the Godot game engine.

Games Made with Unity

Every title below is confirmed as a Unity game by its developer, Unity’s own case studies, or its credits.

• Pokémon GO (2016), Niantic: the augmented-reality hit that sent players walking around the real world to catch Pokémon. Scopely bought Niantic’s games business, including Pokémon GO, in a $3.5 billion deal completed in May 2025.
• Among Us (2018), Innersloth: the social-deduction game of crewmates and impostors, whose 2020 surge leaned on Unity’s cross-platform builds for PC, mobile and console play together.
• Monument Valley 2 (2017), Ustwo Games: the Escher-inspired puzzle sequel, first on iOS and later on Android, PC, Switch, PlayStation and Xbox.
• Hollow Knight (2017) and Hollow Knight: Silksong (September 4, 2025), Team Cherry: Silksong shipped on Unity 6 after years of development by a very small team.
• Genshin Impact (2020), HoYoverse, and Zenless Zone Zero, which reached its full 1.0 release in June 2026.
• Cuphead, Cities: Skylines, Ori and the Blind Forest, Fall Guys and PEAK are other well-known Unity titles.

Is Unity Still Used in 2026?

Yes, heavily. Unity’s own monthly roundups list dozens of new Unity releases every month. In 2026 alone that includes Xenonauts 2 (full release April 2, 2026), Thunder Lotus’s 33 Immortals (June 10, 2026), Nintendo’s mobile game Pictonico! (May 28, 2026) and Paralives entering early access in May. SteamDB counts more than 8,500 Unity games published to Steam in each of the past two years.

The more interesting answer is that Unity has recovered from 2023. Its Q1 2026 results beat analyst estimates, and the engine side has settled into a steady quarterly release rhythm. Studios that left over the Runtime Fee mostly stayed gone, but new projects keep choosing Unity, especially for mobile and XR.

Key Takeaways

• Unity is built in C++ but scripted in C#. You add C++ only through native plugins; IL2CPP generates C++ from your C# at build time.
• UnityScript (“Unity JavaScript”) and Boo no longer exist in Unity. Both compilers were removed in Unity 2019.1.
• Unity 6.3 LTS is the current long-term release, supported to December 2027. Unity 6.0 LTS standard support ended on October 16, 2026, and 6.7 LTS is due in late 2026.
• Unity is still very much in use, with Hollow Knight: Silksong (2025), Xenonauts 2 and 33 Immortals (2026) among recent releases.
• Pricing is per seat: free under $200K revenue and funding, then $2,310 per seat per year for Pro. There is no Runtime Fee; it was cancelled in September 2024.
• CoreCLR is the next big shift: Unity 7, targeted for Q1 2027, moves Unity’s scripting from Mono to CoreCLR with .NET 10 and C# 14.

Frequently Asked Questions

Conclusion

Unity in 2026 is a calmer, more predictable engine than the one developers worried about in 2023. The pricing is back to seats, Unity 6 has settled into a regular LTS-and-update rhythm, and the C# side is about to get its biggest upgrade in years with CoreCLR. For mobile, 2D, XR and small-to-mid-size teams it remains the default choice. The C++ heart of the engine is there whenever you need to reach it through a native plugin.

We’ll update this guide when Unity 6.7 LTS ships and again when the CoreCLR-based Unity 7 lands. In the meantime, compare Unity with more than a hundred alternatives in our directory of C++ game engines.