How We Build Sjufty

How We Build Sjufty – Tech Behind the World

Sjufty is built as a live, evolving project using Unity, C#, and a stack of online services designed to support both open-world exploration and session-based game modes.

This page gives a high-level look at how the game is structured under the hood, how multiplayer works, and how we are preparing the project to scale as more players join.

Engine and Core Technology

Sjufty is developed in Unity using C#. Unity provides the base for rendering, physics, input, and scene management, while all gameplay logic and systems are written as C# scripts on top.

The game uses a scene-based structure with multiple dedicated scenes for different gameplay purposes, such as:

• OpenWorld – where players drive, loot, and work for their money
• StageView – where voting and comfort-mode sessions happen
• Wardrobe and UI-focused scenes – for customization and menus
• Shared utility scenes and managers – for account data, sessions, and transitions

Each scene has its own logic and specialised prefabs, but the goal is always the same: keep systems clear, reusable, and as lightweight as possible.

Multiplayer and Networking

Multiplayer in Sjufty is built on Unity’s Netcode for GameObjects. On top of that, the game uses Unity’s services for Relay and Lobby to allow players to find each other and play together without running their own servers.

Key systems include:

• Lobby – players can be gathered and sorted into stage-based or open-world sessions
• Relay – used to route the traffic between players, acting as the backbone of real-time communication
• Networked prefabs – cars, players, and other entities that need to stay in sync across all clients
• Session logic – code that determines who is host, when scenes change, and how players are moved between modes

The design philosophy is to let Unity’s networking layer handle the heavy lifting while keeping custom logic focused on gameplay and fairness.

WebGL and Browser Play

Sjufty runs directly in the browser using Unity WebGL builds. This allows players to:

• Launch the game without downloads or installation
• Try the experience instantly from a simple link
• Jump in and out in short sessions

To support this, we keep a strong focus on:

• Build size – to keep loading times acceptable
• Asset management – not overloading the WebGL build with unnecessary content
• Simplicity in shaders and effects – enough to look good, but not so heavy that browsers struggle
• Testing on multiple devices – including lower-powered machines

As the project grows, external tools such as CDNs and caching layers are considered to help distribute traffic and reduce load times.

Accounts, Data and Progression

Sjufty uses online account systems to keep player data connected to a login rather than to a single device. Over time, account data is planned to include:

• Level and experience
• Money and earnings
• Owned items and outfits
• Progression and unlocks

This avoids storing critical progression only in local PlayerPrefs and instead moves towards cloud-based persistence. The long-term goal is that a player can log in from multiple devices and still see the same progress.

Fairness and Server Load

One important principle in the technical design is: not everything needs to be networked.

Where possible, Sjufty uses local logic for visual-only elements and reserves network synchronization for things that truly matter: positions, important actions, votes, and shared state.

This helps:

• Keep bandwidth usage lower
• Reduce unnecessary server overhead
• Make the game more scalable in the long run

Debugging tools, logs, and development-only helpers are gradually removed or reduced in live builds, so performance is not wasted on background noise.

Game Modes and Session Flow

Sjufty is built around multiple game modes that share some systems but use them in different ways.

OpenWorld sessions focus on:

• Continuous movement and exploration
• Risk and reward around looting and delivery
• Direct interaction between players

StageView sessions focus on:

• Presentation of players and outfits
• Voting and friendly competition
• Comfort-mode loops that can run while the player relaxes

The code behind these systems is structured to allow scene transitions without breaking the underlying account or network state when possible.

Why Share This?

The goal with this page is not to provide a full technical manual, but to give a transparent look at how Sjufty is built and maintained.

It is also a way to show that behind the visuals and atmosphere, there is ongoing work with architecture, network design, performance, and long-term planning.

As the project continues, this page may be updated with more details about:

• Optimization strategies
• New systems and tools
• Lessons learned from real players joining the world

Sjufty is not just a mood or a lobby. It is also a technical journey, built step by step – in public.