
## Talo’s new Caddy template

If you're a game developer considering hosting your Talo game backend yourself, the new self-hosting option using Caddy could be the easiest way to get started. Talo makes managing game services (like [player stats](/stats), [leaderboards](/leaderboards) and [event tracking](/events)) simple and now you can close the loop with Caddy by setting up a secure and reliable self-hosted Talo instance.

### What is Caddy?

Caddy is a web server known for its simplicity and automatic HTTPS, which means it takes care of SSL certificates and security configurations automatically. That’s a huge win for game developers: it’s one less thing to configure and worry about, which makes Caddy an ideal choice for Talo’s self-hosting. With Caddy handling the secure connections to your backend, you can focus more on building your game and less on managing infrastructure.

### Key benefits of Caddy for self-hosting

1. **Automatic HTTPS and certificate management**  
   Caddy’s best feature is its automatic HTTPS and versatile routing options. You won’t have to deal with provisioning or renewing certificates, keeping your setup hassle-free.

2. **Simplified configuration**  
   Caddy’s configuration files are known for being simple and readable, making it easy to set up without extensive experience in server configuration. When it comes to Talo, this means less time troubleshooting server settings and more time focused on game development.

3. **Lightweight and efficient**  
   Caddy is known for being resource-efficient, which is a good match for Talo. You don’t need heavy infrastructure to support a Caddy-based setup, making it a great choice for developers looking for a balance of affordability and scalability.

## Talo’s other self-hosting options

While the Caddy-based template is a recent addition, it’s not the only way to self-host Talo. Depending on your experience level or preferences you can also use the following templates:

- **Nginx-based template**: If you're more experienced with Nginx, Talo also provides this template as an alternative to the Caddy template. Nginx has been around for a long time and has been battle-tested across countless production setups, making its configuration options slightly more versatile.
  
- **Basic template**: This template is designed for quick and easy setup. If you’re new to self-hosting or just want to get something up and running locally, this option is a great starting point.

These templates are all available in our [self-hosting GitHub repo](https://github.com/TaloDev/hosting), giving you the flexibility to choose the one that best fits your needs. Whether you prefer the automation of Caddy, the familiarity of Nginx, or the simplicity of the basic template, Talo gives you multiple options for easy self-hosting.

## Getting started with Caddy and Talo

If you've settled on our recommended Caddy-based self-hosting template, here’s a quick overview of the setup:

1. **Clone the `hosting` repo**  
Start by cloning the [Talo hosting repository](https://github.com/TaloDev/hosting) to get the latest self-hosting templates. The Caddy template is available in the `caddy` folder.

2. **Set up your environment**  
Rename `.env.sample` to `.env` and fill out all the necessary variables. You can find a reference for [configuration options here](https://docs.trytalo.com/docs/selfhosting/configuration).

3. **Add `A` records**  
Add `A` records for the frontend and backend domains you configured in the `.env` file. This is necessary for Caddy to automatically provision SSL certificates.

4. **Launch the services**  
Finally, use `docker compose up -d` to launch the services defined in the `docker-compose.yml` - including the Talo frontend/backend, databases and Caddy web server. You can inspect the logs for each service using `docker compose logs`.

These steps can also be applied to the other self-hosting templates provided by Talo. Make sure to also check [our documentation](https://docs.trytalo.com/docs/selfhosting/overview) for more info about self-hosting.

## Choose your own adventure

With different templates to choose from, you can pick the self-hosting setup that best matches your needs. The Caddy template is perfect if you want secure HTTPS out of the box, while the Nginx template may suit you better if you’re already comfortable with Nginx. If you’re just looking for something simple, the basic template can get you started quickly.

## Wrapping up

Talo’s self-hosting templates, especially our recommended Caddy-based option, give plenty of flexibility to game developers who want more control over their infrastructure. With options for different experience levels and needs, Talo’s self-hosting setup makes managing your backend easy, secure and scalable.

Explore the [Talo self-hosting documentation](https://docs.trytalo.com/docs/selfhosting/overview) for more details on how these templates can fit into your development setup.

If you have any questions or feedback, feel free to reach out to us on [Discord](/discord). We’re always happy to help you get started with self-hosting your Talo game backend.


A breakdown of Talo’s latest Caddy-based self-hosting option, plus a look at other self-hosting templates available for your game.

Exploring Talo’s new Caddy self-hosting template


## October 2024 overview

This month our main focus has been making [player groups](/players#groups) more powerful and observable. We've added a new demo for the [Godot plugin](/godot) and fixed lots of bugs across the board. Here's a quick overview of what we've been up to:

## Dashboard updates

* **Pinning groups**: You can now pin player groups to the dashboard for easy observability. For example, you could use this for [showing online player counts](/blog/live-player-counts-godot).
* **Group member visibility**: You can now toggle if groups fetched by the new API should include player data. See the [API documentation](https://docs.trytalo.com/docs/http/player-group-api) for more information.

## Backend updates

* **Leaderboard entry props** (shoutout from last month): Leaderboard entries can now have props attached to them similar to [player props](/players#props) and [event props](/events#understand-journeys).
* **Steamworks authentication** (shoutout from last month): You can now authenticate players using Steamworks. Check out our [blog post](/blog/steamworks-authentication) for more information.
* **Handling empty services/identifiers**: You can no longer identify a player with an empty service or identifier.
* **Player groups API**: We've added a new API to fetch an individual player group. This allows you to see groups members (if available) as well as the group's rules. See the [API documentation](https://docs.trytalo.com/docs/http/player-group-api) for more information.

## Godot plugin updates
* **handle_tree_quit option**: You can now toggle whether Talo manages the `handle_tree_quit` notification or if you would prefer to manage it yourself.
* **Saves demo**: We've added a new demo showing off how to easily save and load data in Godot using Talo.
* **GDScript styleguide**: We're now correctly following the GDScript styleguide: size 4 tabs across our scripts.
* **Player groups API**: The new player groups API is now available in the [Godot plugin](/godot).

## Unity package updates
* **Fixed missing namespaces**: We've fixed an issue where some namespaces were missing from Talo files.
* **Player groups API**: The new player groups API is now available in the [Unity package](/unity).

## Have your say: join the community

Thoughts, feedback and roadmap suggestions are all welcome on our [Discord](/discord). We're listening out for what's most important to our community.


All the highlights from Talo’s October 2024 releases across the dashboard, backend, Godot plugin and Unity package.

Changelog: group updates + new Godot game save demo


## How many players are online?

Knowing how many players are currently playing your game is something that almost everyone wants to know. It's always great to see player counts climbing, especially after new updates or announcements.

But how can you track this? You could build your own tracking system, but that's time-consuming and complex - you've got a game to build! That's why we built [Talo](https://trytalo.com), a game backend platform that makes it easy to understand player behaviour and gain oversight over your game's data. In this tutorial, we'll show you how to use Talo to track player counts in your Godot game.

## Online player counts with Talo

Talo makes it easy to segment your players using [player groups](/players#groups). You can use player groups to create distinct buckets of players. For example, in this tutorial, you'll use player groups to check for players with a custom "online" property.

When your Godot game starts, you'll identify the player and set the "online" property to `true`. When they exit the game, you'll set it to `false`. Using Talo's new pinned groups feature in the dashoard, you can see the number of players in the "online" group in real-time.

## Setup the Talo Godot plugin

You need to start by setting up the Talo Godot plugin. You can do this by downloading the plugin from the [Godot Asset Library](https://godotengine.org/asset-library/asset/2936) (or by searching "Talo Game Services" in the `AssetLib` tab of the Godot editor). You can also find the latest version of the plugin on [itch.io](https://sleepystudios.itch.io/talo-godot).

![Install Talo from the AssetLib tab](/blog/live-player-counts-godot/install-assetlib.png)

Once you've downloaded the plugin, import it (typically you want to install plugins under the `addons` folder) and enable it in the `Project > Project Settings > Plugins` window.

![Enable the Talo plugin in the project settings](/blog/live-player-counts-godot/install-enable.png)

You can now run your game - this will create a `settings.cfg` asset inside the folder where you installed the plugin - you'll need this later. To learn more about how to configure Talo, including how to configure your self-hosted version, [check out the docs](https://docs.trytalo.com/docs/godot/install#create-and-update-settings).

### Generating an access key

Next you need to generate an access key for your game. Visit the [Talo dashboard](https://dashboard.trytalo.com), login or create an account (and confirm your email address). Once logged in, create a new game (if you need to) and visit the Access Keys page.

Once there, choose the scopes available to your access key. For this tutorial, you'll need the `read:players` and `write:players` scopes. Create your access key and copy it into the `access_key` field of the `settings.cfg`.

## Creating your group

Talo players can have properties ([known as props](/players#props)) that persist between sessions. As long as you know who the player is, you can set and get these properties. Player groups are able to read these properties and adjust the group's members accordingly.

To create your group, click the `Services` dropdown and go to `Groups`. Create a new group where you check for the `online` prop being equal to `true`. After creating your group you can pin it to your dashboard so you can see the online player count from the dashboard homepage.

![Creating your player group in the dashboard](/blog/live-player-counts-godot/group-setup.png)

## Setting up the game logic

All you need for this tutorial is a scene with a single root node, for example a `Node2D`. Attach a script to your root node with the following content:

```gdscript
extends Node2D

@export var username: String = "username"

func _ready() -> void:
  # prevent Talo from exiting before our online prop logic runs
  Talo.settings.set_value("", "handle_tree_quit", false)

  Talo.players.identified.connect(_on_identified)

  # identify who the player is
  Talo.players.identify("username", username)

func _on_identified(_player: TaloPlayer) -> void:
  # set the prop now that we know who the player is
  await Talo.current_player.set_prop("online", "true")

func _notification(what: int):
  match what:
    NOTIFICATION_WM_CLOSE_REQUEST:
      # update the prop before quitting
      await Talo.current_player.set_prop("online", "false")
      get_tree().quit()
```

This script does the following:
1. Sets the Talo `handle_tree_quit` property to `false`. By default Talo will listen for the `NOTIFICATION_WM_CLOSE_REQUEST` notification to run cleanup operations and then exit. However in this case, the online property should be updated first before the game exits.
2. Identifies the player using the `username` service. The player's username can be customised using the export variable.
3. Once the player is identified, their `online` property is set to `true`. At this point they should be in the "Online players" group you created earlier.
4. If the player closes the game, their `online` property is set to `false` and the game is exited. They will no longer be part of the "Online players" group.

## Testing the online player count

You can now open your game, go to the dashboard, and see the "Online players" group count is 1. If you close the game, it will reset back down to 0. As mentioned earlier, the group can be pinned to your dashboard so you can always see the online player count when visiting the Talo dashboard.

![Pinned online player count in the Talo dashboard](/blog/live-player-counts-godot/pinned-group-dashboard.png)

## Making oversight easy

Talo is designed to be extremely flexible in the way it provides observability and oversight to you. You don't need to spend hours building your own tools when you can just use Talo and the customisable groups to drill down into specific player behaviours.

If you're building a game and you want more oversight over it, come and join our [Discord community](/discord) or follow us on [GitHub](https://github.com/TaloDev) to keep up to date with how we're improving Talo to make game development fun, easy and observable.


Have you ever wondered how many players are current playing your Godot game? Talo makes it easy to find out using player groups.

How to see live online player counts in your Godot game


## A simple but robust game save system

Building a save system is something most game developers will end up doing. Saving and loading data is a fundamental part of game development and can be used for a variety of things such as saving player progress, storing game settings or even saving the state of the game world. There's hundreds of tutorials and ways of approaching this but that doesn't mean you need to roll your own code.

A good save system is built on 3 main principles:
1. **Flexible**: it should be easy to save and load any type of data from anywhere in your game.
2. **Observable**: you should be able to inspect what's being saved and loaded to better understand the state of your game.
3. **Secure**: players should not be able to tamper with their saves. Typically this means saving data on a server but that may prevent players from playing offline.

Building the system described above can be time consuming and complex. That's why we built [Talo](https://trytalo.com) - a game backend platform that makes it easy to save and load game data. In this tutorial we'll show you how to use Talo to save and load game data in your Godot game.

For more information on Talo's save system, [check out the docs](/saves).

## Game saves using Talo

Talo uses all the principles we've outlined above to make it easy to manage saves in your game:

* Talo lets you have direct control over what data you save and how it's subsequently loaded in.
* Talo provides a dashboard where you can see all the data being saved for a player, making it easier to debug save issues.
* Talo is secure: saves can be created, updated and deleted via the [Godot plugin](/godot).
* Talo creates encrypted offline saves that are synced up when the player is online.

## What are we building?

In this tutorial you'll build a simple project that shows creating a save, updating a save and loading a save. The project will have some buttons, each of which can be clicked to increase the number they display. We'll save the state of each button and load it when the game is restarted.

![The demo project you'll be building](/blog/game-saves-godot/saves-demo.gif)

## Setup the Talo Godot plugin

To start saving and loading state, you need to set up the Talo Godot plugin. You can do this by downloading the plugin from the [Godot Asset Library](https://godotengine.org/asset-library/asset/2936) (or by searching "Talo Game Services" in the `AssetLib` tab of the Godot editor). You can also find the latest version of the plugin on [itch.io](https://sleepystudios.itch.io/talo-godot).

![Install Talo from the AssetLib tab](/blog/game-saves-godot/install-assetlib.png)

Once you've downloaded the plugin, import it (typically you want to install plugins under the `addons` folder) and enable it in the `Project > Project Settings > Plugins` window.

![Enable the Talo plugin in the project settings](/blog/game-saves-godot/install-enable.png)

You can now run your game - this will create a `settings.cfg` asset inside the folder where you installed the plugin - you'll need this later. To learn more about how to configure Talo, including how to configure your self-hosted version, [check out the docs](https://docs.trytalo.com/docs/godot/install#create-and-update-settings).

### Generating an access key

Next you need to generate an access key for your game. Visit the [Talo dashboard](https://dashboard.trytalo.com), login or create an account (and confirm your email address). Once logged in, create a new game (if you need to) and visit the Access Keys page.

Once there, choose the scopes available to your access key. For this tutorial, you'll need the `read:players`, `write:players`, `read:gameSaves` and `write:gameSaves` scopes. Create your access key and copy it into the `access_key` field of the `settings.cfg`.

![Creating a new access key in the Talo dashboard](/blog/game-saves-godot/access-key.png)

### Setting up the scene

Let's start by creating a new scene with a `Node2D` root and add a `Control` node that has a `Button` node child. Each button will display the number of times the button has been clicked. Here's the structure of the scene:

![Scene structure in Godot](/blog/game-saves-godot/scene-structure.png)

We've used a grid container so we can layout the buttons in a 3x2 grid. You can use any layout you like, but make sure you have a `Button` node nested under a `Control` node.

For reference, here's our `.tscn` [file for this scene](https://gist.github.com/tudddorrr/2a16d1ab9f4382abbd9012a1f1deb3ec).

### Making buttons loadable

You'll only need two scripts for this demo: one for our buttons and one for managing state.

Let's start with the button script. This script will handle the button's state and update the button's text when clicked. Here's the script you should attach to the `Control` node (the parent of your `Button` node):

```gdscript
class_name LoadableButton extends TaloLoadable

var button: Button
var clicks: int = 0

func _ready() -> void:
  super()
  button = get_child(0)

func register_fields() -> void:
  register_field("clicks", clicks)

func on_loaded(data: Dictionary) -> void:
  clicks = data["clicks"]
  button.text = "%s clicks" % clicks

func _on_button_pressed() -> void:
  clicks += 1
  button.text = "%s clicks" % clicks
```

This script extends `TaloLoadable`, a helper class provided by the Talo plugin. `register_fields` tells Talo what fields to save and `on_loaded` is called when the object is loaded.

You'll need to connect up the `pressed()` signal on your `Button` child node to the `_on_button_pressed` method in the script. You'll also need to add a unique identifier for your button so that Talo knows which button it's saving and loading. You can do this by setting the `ID` property in the inspector (you could also do this via the script):

![Setting the ID property in the Godot inspector](/blog/game-saves-godot/loadable-id.png)

At this point you can duplicate your button container as many times as you like (we're going for 6) and set the `ID` property to a unique value for each button.

### Managing the state

Next, you'll need a state manager to handle loading saves, saving the game state and updating the game state. Create a new script and attach it to the root node of your scene. Here's the script:

```gdscript
extends Node2D

@export var username: String = "username"

func _ready() -> void:
  Talo.players.identified.connect(_on_identified)
  Talo.players.identify("username", username)

func _on_identified(_player: TaloPlayer) -> void:
  var saves = await Talo.saves.get_saves()
  if saves.is_empty():
    await Talo.saves.create_save("save", {})

  await Talo.saves.set_chosen_save(Talo.saves.all.front())
```

This simple script identifies the player using the `username` property. It then fetches the player's saves and creates a new save if the player doesn't have any. Finally, it sets the chosen save to the first save in the list.

You'll need to update the `LoadableButton` script before you can fully test this out. Update the `_on_button_pressed` method to update the save when it's clicked:

```gdscript
func _on_button_pressed() -> void:
  clicks += 1
  button.text = "%s clicks" % clicks
  await Talo.saves.update_current_save() # update the save
```

### Checking the finished demo

All of the logic is now ready. You can run your game and start clicking the buttons. You should see the number of clicks persist between runs. If you want to test the offline save feature, you can run the game, disconnect from the internet and click the buttons. When you reconnect to the internet and run the game again, you should see the number of clicks persist.

With Talo, you can easily see the content of your save directly in the dashboard. Simply login to the dashboard, head over to the `Players` service, go to your player's profile and choose `Saves`. You should be able to see a visual representation of the data saved for your player:

![The player's save content in the Talo dashboard](/blog/game-saves-godot/save-content.png)

## Summing things up

How quick was that!? Using just two scripts, we've shown how easy it is to save and load data with Talo. We've covered how to set up the [Talo Godot plugin](/godot), create a save, update a save and load saves. You can now extend this script to work with other objects and add more properties. You could even think about automatically setting the `ID` property on your buttons to make it easier to manage.

Saves are just one of the features Talo provides. You can also use Talo to manage player data, leaderboards, achievements and more. If you're building a game that needs persistence or want to make more data-driven decisions, join our [Discord community](/discord) or follow us on [GitHub](https://github.com/TaloDev) to keep up to date with the latest and greatest releases for our open source game backend.


A quick and easy example of how to use Talo Game Saves to handle saving and loading scenes in your Godot game even when players are offline.

How to load and save game state using Godot

Continuity is a new resilience layer for keeping your game data in sync when Talo can't be reached or a player is offline in your Godot or Unity game.

Sign up

Introducing Talo Continuity

Continuity is here!

How does it work?

Configuring Continuity

Now available in the Talo Godot plugin

Join our community

Get started

More from the Talo Blog

Exploring Talo’s new Caddy self-hosting template

Changelog: group updates + new Godot game save demo

How to see live online player counts in your Godot game

How to load and save game state using Godot