Coding Guideline for Unity C#

Document style guideline for Unity and C# within our company, so the game developers can follow and create a high quality of code and easily collaborative projects.

As a programmer, it is very important to follow a coding standard and make sure others can read and easily understand his code. While there's not majority guideline of coding standard in Unity and C#, you can somehow write whatever you like, but in this article, I'm going to show you our style and format guideline within the company. We have tried to adopt different styles throughout these years and came out the one we feel most comfortable.

Our 3 golden rules to forms our style standard:
1. Follow Unity's style in Scripting Reference
2. The rest follow Microsoft's C# Coding Conventions
3. Minor tweak where we believe that can make the code clearer

Folder Structure

All similar files should be grouped in the root folders:

  Animations       Animation clips
  Editor           Editor specified scripts, prefabs, etc
  Fonts            Fonts used in game
  Materials        Texture materials
  Prefabs          In-game prefabs
  Resources        Unity resources assets
  Scenes           Scenes
  Scripts          Code scripts, grouped in sub-folders
  Sounds           Musics, sounds
  SweatyChair      Company folder that share across projects
    (ModuleName1)  Module name, e.g. DailyLogin
      (Scripts)    Scripts within the module
      (Prefabs)    Prefabs within the module
      ...          Other assets grouped in folders
    ...            Other modules
  Textures         Image textures
    UI             Texture used for UI
    Icons          App icons

We have a SweatyChair folder, which containes a number of well-structure modules and sync across projects using Git submodules. We we are always reuse the commond code and able to perform rapid prototyping.

File Naming

File naming is simple, always use Pascal Case except for images:

  • Folders - PascalCase
  • Images - hyphen-
  • The rest - PascalCase
    ScriptName.cs, PrefabName.prefab, SceneName.unity

The reason images use hyphen naming is that most images are also used in our website / press-kit. Hyphen naming is the majority naming convention for web image and it's also search engine friendly. Using the same name can save us time renaming and easily find the same image switching between Unity and web.

Scripts Naming

While each script has its unique purpose and use cases, we follow these naming rules and so we can still roughly know what the script is for by simply reading the filenames:

  • XxxPanel, XxxSlot, XxxButton, etc for UI
    MenuPanel, AchievementSlot, CoinShopButton
  • XxxManager, for master scripts that control specific workflow (only ONE instance in the scene)
    DailyMissionManager, AchievementManager
  • XxxController, for scripts controlling a game object (one or many in the scene)
    PlayerController, BossController, BackgroundControler
  • XxxDatabase, for a database (e.g CSV) which contains a list of data rows
    WeaponDatabase, CardDatabase
  • XxxData, for data row in a CSV database
    WeaponData, CardData
  • XxxItem, for in-game item instance
    CardItem, CharacterItem
  • XxxGenerator, for scripts instantiate GameObjects
    ObjectGenerator, LandGenerator
  • XxxSettings, for settings scripts inherent Unity's ScriptableObject class
    AchievementSettings, DailyLoginSettings
  • XxxEditor, for editor-only scripts inherent Unity's Editor class
    TutorialTaskEditor, AchievementSettingsEditor

Difference between Manager and Controller is Manager should be singleton or static, and it controls a specific game logic that may involve multiple objects and assets, while Controller controls an object and may have multiple instances. For example, there are multiple EnemyController in the scene and each control one enemy. We will discuss more on this in a singleton article.

Difference between Data and Item is that Item is an instance in-game, and in most cases Item contains a Data. For example CardData has all preset attributes of a card, while CardItem has its CardData plus attributes that vary for different players, such as card level. We will talk about more this in another data structure article.

Variable Naming

Similar to file naming, variable naming allow us to know what the variable is for without reading though all code:

  • Use camcelCase, always as of a noun or in a form of (is/has)Abjective
    hasRewarded, currentPosition, isInitialized
  • Prefix with an underscore for private and protected variables
    _itemCount, _controller, _titleText
  • All capital letters for const
  • All capital letters and PREFS_XXXX for PlayerPref keys
    private const string PREFS_LAST_FREE_DRAW = “LastFreeDraw”;
  • Use xxxGO for scene GameObject variables
    optionButtonGO, backgroundMaskGO
  • Use xxxPrefab for scene GameObject variables
    weaponSlotPrefab, explosionPrefab
  • Use xxxTF for Transform variables
    weaponTF, armTF
  • Use xxxComponent for all other components, abbreviate if needed
    eyesSpriteRenderer / eyesSR, runAnimation / runAnim, attckAnimationClip / attackAC, victoryAudioClip / victoryAC
  • Use xxxxs for arrays
    slotPrefabs = new Prefabs[0]
    achievementIds = new int [0]
  • Use xxxxList for List and xxxxDict for Dictionary
    weaponTransformList = new List()
    achievementProgressDict = new Dictionary()
  • Use nounVerbed for callback event
    public static event UnityAction gameStarted
    public static UnityAction characterDied

Unity use prefix m_ for private/protected variables, and s_ for static variables (see their BitBucket). We found that this makes the code very hard to read, so we leave one underscore for private/protected variables and keep it the same for both static and non-static variables.

Callback event follow Unity's event naming convention, e.g. SceneManager.activeSceneChanged.

Functions Naming

  • Use PascalCase, start with a verb and followed by a noun if needed
    Reward(), StartGame(), MoveToCenter()
  • Use OnXxxxClick, for UI button clicks
    OnStartClick(), OnCancelClick()
  • Use OnNounVerbed, for callbacks
    OnChestOpened(), OnBuyWeaponConfirmed()

Member Properties

If a function has no input, use member property (aka get/set property) instead, in PacelCase as well:
bool IsRewarded() { }
bool IsRewarded {get { return …} }
Or even in a shortened form as
bool IsRewarded => ...;

Also, use member properties where a variable can only set internally but can be accessed publicly:
public int Id { get; private set; }
public Sprite IconSprite { get; private set; }

Variables / Functions orders

Having a consistent order can greatly save our time on looking for a specific variable or function:

MyCalss : Monobehavior
  // Constant variables
  public const int CONST_1;
  private const string CONST_2;

  // Static variables
  public static int static1;
  private static string _static2;
  // Editor-assigned variables
  [SerializeField] public Image maskImage;
  [SerializeField] private MyClass _anotherComponent;

  // Other varaibles
  public int primitiveVariables1;
  private string _primitiveVariable2;

  // Properties
  public int Property1 {get; set;}
  private string _roperty2 {get; set;}

  // Unity functions

  // Other custom functions

  // Unity functions

  // Eebug functions that only runs in Editor
  private void DebugFunction1()
  private static void DebugFunction2()

You can also group valuables and functions in a region in large scripts (but not too large enough to be split into another script):

#region Timer
  private const int RESET_SECONDS = 180;
  private float _secondsLeft;
  public float canResetTime => _secondsLeft < 0;
  public void ResetTime()
    _secondsLeft = RESET_SECONDS;
#endregion Timer
... // Other regions

Code Formatting

We use K&R style which is already preset in Mac Visual Studio:

While there's not K&R in Windows (Why, Microsoft?), just a little bit effort to manually set few ticks:

Brackets and Newlines

For single-line conditional statements we do not need any brackets:

if (1 == 1)
if (1 == 1) return true;
if (1 == 1) {

Many developers, includes Unity, favourite putting newlines after open bracket ( { ). It may make the code looks more tidy and symmetric, but also creates a lot of unuseful lines and making script scrolling much more often and longer. Every bit count. If you spend 1 more second on scrolling a day, you probably wasted 5 minutes of valuable time a year.


Single line comments should include a space after the slashes:
// Notice the space after the two slashes
Temporarily commenting out code should not include a space after the slashes, to be differentiated from the normal comment:
TODO comments should include the space after the slashes and then 2 spaces after the colon following the TODO
// TODO: Notice the space after the slashes and the 2 spaces after the colon of todo

That's all. This may go bigger when you adopt more latest .Net syntax. There are also a few other good guidelines if you want to read more. Free feel to follow this style if you think it's reasonable and helpful, so we may create a better game dev world where code is clean and please to read. 😀

(Originally posted in Richard's Blog)

Latest Jobs

Manticore Games

San Mateo, California
Senior Software Engineer - Mobile

Sony PlayStation

San Diego, California
Sr. Online Programmer

The Walt Disney Company

Glendale, California
Associate Marketing Manager - Walt Disney Games

Insomniac Games

Burbank, California
Accessibility Design Researcher
More Jobs   


Explore the
Subscribe to
Follow us

Game Developer Job Board

Game Developer Newsletter


Explore the

Game Developer Job Board

Browse open positions across the game industry or recruit new talent for your studio

Subscribe to

Game Developer Newsletter

Get daily Game Developer top stories every morning straight into your inbox

Follow us


Follow us @gamedevdotcom to stay up-to-date with the latest news & insider information about events & more