When Microsoft originally created the .Net platform it created it principally for the Windows platform. However, Microsoft published the language specification to ECMA and shortly thereafter, the Mono open source project was created which brought the .Net platform to other platforms including OSX and Linux. At its core the Unity scripting system is built upon the .Net runtime and the benefits afforded it through the Mono project. While it was certainly possible that the Unity scripting system could have been based upon Java or some other system, .Net provided (out-of-the-box) a rich system for assemblies that made cross language functionality trivial to implement.

Multiple scripting languages are possible in Unity due to the Common Language Infrastructure (Cli) of .Net. The purpose of the Common Language Infrastructure (CLI), is to provide a language-neutral platform for application development and execution, including functions for exception handling, garbage collection, security, and interoperability. By implementing the core aspects of the .NET Framework within the scope of the CLI, this functionality will not be tied to a single language, but will be available across the many languages supported by the framework. Microsoft's implementation of the CLI is called the Common Language Runtime, or CLR.

Boo is an object-oriented, statically typed programming language that seeks to make use of the Common Language Infrastructure's support for Unicode, internationalization and web-applications, while using a Python-inspired syntax and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and first-class functions. Boo has been actively developed since 2003.

Boo is free software released under an MIT/BSD–style license. It is compatible with both the Microsoft .NET and Mono frameworks.

import UnityEngine
import System.Collections

class example(MonoBehaviour):

    def Start():
        curTransform as Transform
        curTransform = gameObject.GetComponent[of Transform]()
        curTransform = gameObject.transform

    def Update():
        other as ScriptName = gameObject.GetComponent[of ScriptName]()
        other.DoSomething()
        other.someVariable = 5

JavaScript is an implementation of the ECMAScript language standard and is typically used to enable programmatic access to computational objects within a host environment. It can be characterized as a prototype-based object-oriented scripting language that is dynamic, weakly typed, and has first-class functions. It is also considered a functional programming language like Scheme and OCaml because it has closures and supports higher-order functions.

While UnityScript is, on the surface, syntactically similar to Javascript, the implementation used by Unity is not entirely ECMAScript compliant.

function Start () {
  var curTransform : Transform;

  curTransform = gameObject.GetComponent(Transform);
  // This is equivalent to:
  curTransform = gameObject.transform;
}

function Update () {
  // To access public variables and functions 
  // in another script attached to the same game object.
  // (ScriptName is the name of the javascript file)
  var other : ScriptName = gameObject.GetComponent(ScriptName);
  // Call the function DoSomething on the script
  other.DoSomething ();
  // set another variable in the other script instance
  other.someVariable = 5;
}

C# (pronounced "see sharp")[6] is a multi-paradigm programming language encompassing imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines. It was developed by Microsoft within the .NET initiative and later approved as a standard by Ecma (ECMA-334) and ISO (ISO/IEC 23270). C# is one of the programming languages designed for the Common Language Infrastructure.

C# is intended to be a simple, modern, general-purpose, object-oriented programming language.

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
  void Start() {
    Transform curTransform;
    curTransform = gameObject.GetComponent<Transform>();
    curTransform = gameObject.transform;
  }
  void Update() {
    ScriptName other = gameObject.GetComponent<ScriptName>();
    other.DoSomething();
    other.someVariable = 5;
  }
}