“Should I make my game in Unreal or Unity?” is a frequent conundrum for gamedevs, and one of the biggest sticking points is Unity’s use of C# versus Unreal’s C++. Freeform Labs' dilemma while developing ElemenTerra was that we preferred Unreal's renderer and editor but Unity’s C# scripting. Our solution was to integrate the open-source Mono-UE plugin, which lets us write C# code for our Unreal game!

C# versus C++ is a complex topic you can read about elsewhere. We’re fluent in both at Freeform Labs, but prefer C# for its faster development speeds:

Overall, being able to work in C# was a huge productivity boost that justified jumping through a few hoops to integrate the plugin.

The Basics of Mono-UE

Let’s start with the core premise: Mono-UE works by hooking C# classes into the same bindings that connect Blueprints and C++.

Those who’ve used Unreal will be familiar with making “Blueprint” children of C++ classes. Blueprint classes are authored with a visual editor that can add new components, scripting nodes, and plenty more. In C++ programmers use macros like UCLASS, UPROPERTY, and UFUNCTION to choose which definitions to expose to Blueprints. The compiler then creates “bindings,” Blueprint-accessible wrappers around C++ code that allow the two ecosystems to communicate.

Mono-UE allows us to take these same bindings and create C# classes instead of Blueprints. The UCLASSes that are extensible by Blueprints can be inherited from in C#, and C# can call and override Blueprint-accessible UFUNCTIONs. This alone encompasses a huge swath of functionality, and lets us write complex gameplay logic in C# code. What’s more, C# classes can themselves be extended by Blueprint children!

Here’s a simple example of a Mono-UE C# Class, with comment blocks highlighting the connection points between C# and C++:

/// A new C# class that extends Unreal's "AActor," which is defined in C++
public class MyCSharpActor : Actor
{  
    /// Overridden class constructors:  
    protected MyCSharpActor(ObjectInitializer initializer) : base(initializer) {}  
    protected MyCSharpActor(IntPtr inNativeObject) : base(inNativeObject) {}   
   
    /// C# override of the ReceiveTick function, which is defined in C++  
    protected override void ReceiveTick(float deltaSeconds)  
    {     
        base.ReceiveTick(deltaSeconds)
        // C# can invoke the UFunctions SetActorLocation and GetActorLocation,
        //  just as we would from a Blueprint or C++:
        this.SetActorLocation(this.GetActorLocation() + new Vector3(1f, 0f, 0f));
    }
   
    /// Custom function that Blueprints can call because of the UFunction and
    ///  BlueprintCallable attributes  
    [UFunction, BlueprintCallable, Category("My C# Actor")]
    protected void MyBlueprintCallableFunction(int input)  
    {
        // ...  
    }
    
    /// Custom function with no UFunction attributes, callable only by other C# code
    public void MyCSharpOnlyFunction(int input)  
    {       
        // ...  
    }       
}

Mono-UE is open-source software maintained by Mikayla Hutchinson and a lovely group of other volunteers to whom we are deeply grateful. The setup process is detailed here. With the plugin still in development and some features missing or unfinished, be aware that you’ll need to pick up a handful of idiosyncratic workarounds as you learn to use it.

Our Mono-UE Workflow

Now that we’ve established the essentials, let’s talk about the day-to-day of working with this plugin! I spent a year of my life in Mono-UE and could go on forever, but for brevity here are just a few usage notes:

With these methods we enjoyed all the benefits of C# described above: faster build times, more responsive IDEs, better error messages, and exception handling that doesn’t crash the engine!

What about performance?

ElemenTerra is a VR game, which required us to hit 90+ fps. One of the main draws of C++ is that it’s a low-level language that can run extremely fast; does using C# then put us at a liability? The answer is not so black-and-white.

To start with the facts, we’ve observed that Unreal C++ runs unconditionally faster than Mono-UE C#. Where things get gray is that sometimes C++ is significantly faster, but often the difference is trivial. For generic algorithms and math functions we saw very little difference, but C# was slower when we were doing a lot of thunks. “Thunk” is a silly software term which in this context refers to a call from C# into an Unreal C++ function. These jumps between runtime environments are inherently expensive, and rack up a performance cost when done en masse.

This is a factor that needs to be respected, but is by no means a dealbreaker on Mono-UE. Here are the best-practices we used:

With these practices in place, we enjoyed the productivity boost of C# and still reached 90fps.

Is Mono-UE Right for Me?

This article is about why Mono-UE was the right choice for our team, and we have no regrets. If I've piqued your interest, I’ll close with advice for anyone interested in trying Mono-UE themselves.

Programming Languages and Peace of Mind

As game developers, picking the right tool is important both for the quality of our craft and for the quality of our lives. Personally, I find Mono-UE extremely fun to use: C# is a language where I can get into a great flow state, and not being interrupted by compile times or obtuse errors helps me maintain focus. Whatever you do decide to use, I hope this article has inspired you to reflect on your own development workflow!

If you’re interested in trying Mono-UE yourself, this landing page will direct you to the source code and some community resources. Also feel free to contact us directly if you need a tip or want to talk more. Until next time!

Originally posted on the Freeform Labs Development Blog.

Freeform Labs, Inc. is a games and software development team with a commitment to providing the highest quality of digital craftsmanship, and a mission to inspire learning and creativity through cutting-edge experience design. The team is centrally located in Los Angeles, and maintains a network of trusted partners across the globe. With specialized experience in VR, AR, Game AI, and more, Freeform Labs provides an array of services including consultation, work-for-hire software development, and on-site "ship it" assistance. The company's portfolio includes work for Microsoft, Disney, and Starbreeze - as well as award-winning original content.