Create Your First Game Project with Lakona Hub

Lakona Hub gives you a guided desktop workflow for creating and opening a complete Lakona project. The game client, shared C# contracts, and .NET server are created together, so you can explore one connected workspace and run the game locally.

Lakona Hub creates three connected parts:

Client/ is the Unity project you open and run.
Shared/ contains the C# messages used by Unity and the server.
Server/ is a .NET program that receives requests and applies game rules.

A server is simply another program in this workflow. Unity sends a login or gameplay request to it; the server checks the rules and sends a result back. By the end of this page, the generated Unity game will connect to a local server, accept a player name, and show the first game scene.

First runnable Unity project

Create a project in Lakona Hub, open the client and server, start the local server, then press Play in Unity.

MyGame/ Client/ Unity project Shared/ messages and contracts Server/ .NET game server

Prepare

Have Hub, Unity, and a server IDE ready.

Create

Fill in one project form.

Open

Open the server and client.

Play

Run the local server, then Unity.

Before you start

Lakona Hub

Desktop application for your operating system.

Download Lakona Hub

Unity 2022 LTS

Set up the editor through Unity Hub. Unity Hub and Lakona Hub are different applications.

You will also need an IDE for the server, such as Rider, Visual Studio, or Visual Studio Code. Lakona Hub can detect these applications and use the one you select in Settings. If no compatible .NET 10 SDK is available, Hub can manage a private copy from the Runtime settings.

1. Open and prepare Lakona Hub

Start Lakona Hub.

Open Settings in Lakona Hub before creating the project:

Check the Runtime card. If it says that .NET 10 is required, choose Install .NET SDK and confirm.
In Server editor, choose the IDE you want to use for the server.
In Detected tools, choose Refresh detection if Unity or an IDE was added while Lakona Hub was already open.

Lakona Hub does not change your system PATH when it manages its private .NET SDK. The SDK is used by Hub’s project operations and can be managed from Hub.

2. Create a project in Lakona Hub

Go back to Projects and click Create project. The form shows every setting at once. Use these values for the first Unity project:

Recommended first project settings

Project name:       MyGame
Client type:        Unity
Client version:     Unity 2022 LTS
Transport:          WebSocket
Serializer:          MemoryPack
NuGetForUnity source: OpenUPM

The fields mean:

Field	What it controls	First-project choice
Project name	The new folder name and the generated C# project names.	`MyGame`
Output location	The parent folder where Hub creates `MyGame/`.	Any empty folder you use for projects
Client type	Which client project Hub creates.	`Unity`
Client version	Which Unity editor the generated client expects.	`Unity 2022 LTS`
Transport	How Unity and the server send messages.	`WebSocket`; leave the default
Serializer	How C# messages are encoded for the connection.	`MemoryPack`; leave the default
NuGetForUnity source	Where Unity-side NuGet packages are obtained.	`OpenUPM`; leave the default

Hub shows the final path under Project will be created at. Check that it is the folder you want, then click Create project.

Project creation may take a few minutes. Hub creates the ordinary project files and starts the selected Unity editor in a temporary restore project so it can prepare and verify the Unity packages. Wait for the operation to finish before opening the client.

When creation succeeds, MyGame appears in the My projects list.

3. Open the generated project

The project row has separate actions for the server and the client:

Server → Open

Opens the Server/ folder in the server IDE selected in Settings.

Client → Open

Opens Client/ in the matching Unity editor.

More → Open project folder

Opens the top-level MyGame/ folder in the file manager.

Package

Creates a deployable server or Hotfix archive. You do not need this for the first local run.

If a button is disabled, Hub has not found a matching application. Go to Settings → Detected tools, refresh the list, or use Add application to select the editor executable manually.

Click Open in the Client column and wait for Unity to import packages and compile scripts. The generated game scene is:

Client/Assets/Scenes/Game.unity

Click Open in the Server column as well. This opens the server files; it does not start the server yet.

4. Start the local server

Lakona Hub manages the project and opens the right tools. It does not build, start, stop, or supervise the server process. Start the server from the IDE Hub opened, or from a second terminal in the MyGame/ folder:

Build the generated server once

dotnet build "Server/Server.slnx"

After the build succeeds, start the server and leave this terminal open:

Run the local server

dotnet run --project "Server/App/Server.App.csproj" --no-build

The default WebSocket connection is ws://127.0.0.1:20000/ws. The generated server also exposes a local readiness check at http://127.0.0.1:20080/_lakona/health/ready. From another terminal, you can check it with:

Check that the server is ready

curl http://127.0.0.1:20080/_lakona/health/ready

A JSON response means the local server is listening. If the check cannot connect, look at the terminal running dotnet run and make sure it is still open.

5. Run the Unity client

With the server still running:

Return to the generated Unity project.
Open Assets/Scenes/Game.unity if Unity has not opened it.
Press Play.
Enter a name and click PLAY NOW.

Unity sends the login request to the server. The server checks the name and returns the result; after a successful login, the generated game scene appears.

Keep both programs running

Unity is the client process. dotnet run is the server process. Stop the server with Ctrl+C when you finish testing.

What to edit next

The generated project is made from ordinary files. Start with the folder that owns the behavior you want to change:

Client/

Unity scenes, UI, input, and client-side connection code.

Shared/Contracts/

Request, response, and notification types that Unity and the server both use.

Server/Hotfix/

Game rules such as validating a player name or changing what happens after login.

Server/App/

Server startup and local configuration, such as the listening port.

For example, to add a field to a login request, add it under Shared/Contracts/Game/, rebuild the server, and then read the field from the corresponding code in Server/Hotfix/. Both Unity and the server compile against the same C# type, so they agree on the data shape.

After changing shared or server code, rebuild the hotfix output before starting the server again:

Refresh server game code

dotnet build "Server/Hotfix/Server.Hotfix.csproj"

Use Hub for your next steps

Open an existing project

Use Import existing project on the Projects page and select the project's top-level folder. Hub reads its structure and adds it to the list; it does not add hidden management files or change the project.

Package a server

Click Package beside a project, choose Deployable server package, select Release and a runtime such as win-x64 or linux-x64, then choose Build package.

Package a Hotfix

Choose Hotfix package in the same dialog when you only changed Server/Hotfix/. Hotfix packages do not need a runtime selection.

Hub opens the output folder after a successful package. Packaging is a local file operation; uploading the archive or deploying it to a remote machine is a separate operation.

Hub creates

A complete Unity, shared-contract, and server project in one folder.

Hub opens

The matching Unity editor and the server IDE you selected.

You run

The server and Unity as two local programs while you develop.

Prefer the command line?

Lakona.Tool is the command-line path for creating and packaging Lakona projects. It is useful when you prefer a terminal, want a repeatable setup command, or need to create a project from a script or CI job.

Install the tool once:

Install Lakona.Tool

dotnet tool install --global Lakona.Tool

From the directory where you keep your projects, create a Unity project with the same settings used in this tutorial:

Create a Unity project from the terminal

lakona-tool new --name MyGame --client-engine unity --client-engine-version 2022 --transport websocket --serializer memorypack --nugetforunity-source openupm

If you would rather answer questions one at a time, use the interactive form:

Create a project interactively

lakona-tool new

When the command finishes, open MyGame/Client/ in Unity and follow 4. Start the local server and 5. Run the Unity client above. The CLI creates the project; you still run the server and Unity as two local programs while developing.

To create a deployable Linux server package from the project root, run:

Package the server

lakona-tool server pack --runtime linux-x64 --configuration Release

The package is written to Server/Build/ by default. Keep all options in the command when using it in CI so it can run without prompts.

From a local game to a real cluster

Your first project is the starting point. Continue with Agar: from a local game to a distributed cluster to see the same game grow into a complete system with separate application, database, cache, and monitoring nodes, plus OpenTelemetry-based observability.