## Start Using C# in Godot Engine: A Quick Guide for Unity Users

If you're a Unity developer transitioning to Godot, you'll be happy to know you can put your C# skills to use. Here’s a step-by-step guide to get started, along with some important tips about C# support in the Godot engine.

### 1. Get the Right Godot Version

Go to the [official Godot download page](https://godotengine.org/download/windows) and ensure you get the `.NET` version (formerly called Mono) of Godot. You’ll see ".NET" in the top right of the project manager if you have the correct version. If not, download and install the .NET version.

### 2. Create a C# Script

In your Godot project, right-click in the FileSystem panel and choose to add a new script. You’ll see an option to select either GDScript or C#—choose C#. Give your script a name, or leave the default one, and click Create.

**Note:** The built-in Godot script editor doesn’t offer autocomplete or C# formatting. To work efficiently, you’ll want an external editor, like Visual Studio Code.

[IMAGE - "Person installing Visual Studio Code on a computer"]

### 3. Set Up Visual Studio Code

- Download VS Code from the official website.
- In Godot, go to `Editor` → `Editor Settings`, scroll down and open `Dotnet` → `Editor`. Select Visual Studio Code as your external editor.
- Next, open any C# script. VS Code should launch.
- You may be prompted to "Trust the authors" of the project—click `Yes`.

### 4. Enable C# Autocomplete in VS Code

- Go to the Extensions tab in VS Code and search for `C#` (by Microsoft). Install this official extension.
- After installation, restart VS Code by closing it and reopening your C# script in Godot. Autocomplete for classes such as `GD` and signals should now be available.

### 5. Test Your Setup

In your script's `_Ready()` method, try this:

```csharp
GD.Print("Hello world!");

```

Attach the script to a node, run your scene, and you should see "Hello World" in the output.

![](https://cms.cococode.net/assets/c81400c0-fd6f-4e26-8290-3ef5559b519e)

---

### 6. Example: Porting a Simple Script from GDScript to C#

Here’s a simple scenario: a button that increases a coin counter and updates a label.

1. Define an integer for coins:
    
    ```csharp
    int coinsValue = 0;
    
    ```
    
2. Connect the button’s `pressed` signal to your script in the `Node` tab. Rename the handler (e.g., `OnGrantCoinsButtonPressed`) for best C# practices.
    
    ```csharp
    public void OnGrantCoinsButtonPressed()
    {
        coinsValue += 10;
        GD.Print(coinsValue);
    }
    
    ```
    
3. To update the label, enable `Unique Name` on your Label node. In your script:
    
    ```csharp
    Label coinsValueText;
    
    public override void _Ready()
    {
        coinsValueText = GetNode<Label>("CoinsValueText");
        coinsValueText.Text = coinsValue.ToString();
    }
    
    ```
    
    And in your button handler, update the label:
    
    ```csharp
    coinsValueText.Text = coinsValue.ToString();
    
    ```
    

![](https://cms.cococode.net/assets/78bcbc2e-9178-4f18-acb4-f273d83067d8)

---

### 7. Debugging C# in Godot 

Visual Studio Code allows to atatch a debugger to running Godot game. This way you can place breakpoints in your code and resolve any problems much faster!

Here is a step by step guide:

In Visual Studio Code go to “Run and Debug” tab

Click “Create a launch.json file” and select any template (for example C#) That will create a new file .vscode/launch.json

Replace all contents of this file with this:

```csharp
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Play",
      "type": "coreclr",
      "request": "launch",
      "preLaunchTask": "build",
    // Replace your "program" path with path to your Godot installation.
    // Here you can find some examples (remember to replace [user]!):
    // /Users/[user]/Downloads/Godot_mono.app/Contents/MacOS/Godot
    // /Applications/Godot_mono.app/Contents/MacOS/Godot
    // C:/Users/[user]/Downloads/Godot_v4.1-stable_mono_win64/Godot.exe
    // C:/Program Files/Godot/Godot.exe
      "program": "[ENTER PATH HERE]",
      "args": [],
      "cwd": "${workspaceFolder}",
      "stopAtEntry": false,
    }
  ]
}
```

Please enter your correct path to the Godot Engine in "Program" value. You can find example paths in the comments. Please remove all the comments after finished work.

Create a new file in .vscode folder called tasks.json

Paste this contents in .vscode/tasks.json:

```csharp
{
    "version": "2.0.0",
    "tasks": [
      {
        "label": "build",
        "command": "dotnet",
        "type": "process",
        "args": [
          "build"
        ],
        "problemMatcher": "$msCompile",
        "presentation": {
          "echo": true,
          "reveal": "silent",
          "focus": false,
          "panel": "shared",
          "showReuseMessage": true,
          "clear": false
        }
      }
    ]
  }
```
  save both files and try out debugging! Open "Run and Debug" tab and press "Play". That should build and open your Godot game in Debug mode. In this mode all breakpoints will be triggered


### Final Notes on C# Compatibility in Godot

While C# works great for most game logic, note that not all Godot extensions and plugins support C# yet (especially editor plugins). For most gameplay scripting, you’re good to go, but if you need advanced plugins, check for C# compatibility first.

Switch from Unity to Godot and keep using C#: Learn to set up C# scripts, VS Code, and debugging in Godot with this simple step-by-step guide.

Using C# in Godot with Visual studio code

Godot RPG course