GitHub | Documentation | Become a Patron

Is Colyseus what I'm looking for?



  • For a long time I've been looking for alternatives to BYOND and Roblox: an engine that would make networking in multiplayer games easy without being opinionated about everything else.

    Is Colyseus that? Judging by the description, it is, but it also seems to include extra features.

    Couldn't matchmaking be built on top of state synchronization, as a separate library?

    Does it really need scaling? (Unless scaling is somehow free?)

    Are there plans to support transport layers other than WebSocket? (Yes)

    Does it include client-side prediction?

    What are the assumptions this framework relies on, what are the limitations?

    Most of these questions have probably been answered before elsewhere, so relevant links are also welcome :slight_smile:


  • administrators

    Hi @Kinrany, thanks for checking out the project.

    Is Colyseus that?

    AFAIK these platforms you mentioned will provide servers and resources to host your game. When using Colyseus it will be up to you where to host the server and scale it (if necessary). As Colyseus is just a networking framework, it also doesn't provide any kind of game logic out of the box. You'd need to implement everything by yourself.

    it also seems to include extra features

    The major feature of the framework is having the entire state of a game session being synchronized automatically from the server to all connected clients. This works great if your game state is not too big. Otherwise it's recommended to broadcast/dispatch events instead of using the state.

    Couldn't matchmaking be built on top of state synchronization, as a separate library?

    In theory, yes. Currently, we haven't seen a use case for this. Most games need to have multiple sessions, and matchmaking comes along with it.

    Does it include client-side prediction?

    Not at the moment. I believe client-side prediction is not easily pluggable in a way that the framework abstract everything for you. It depends on the type of game you're making. Most HTML5 games out there don't use client-prediction at all. I'd love to have this if possible, though.

    What are the assumptions this framework relies on

    The assumptions are basically: your game can have multiple game sessions going on at the same time; You'll need to write all game logic on server-side by yourself; You'll need to update the client's visual state as events arrive from the server.

    what are the limitations?

    The limitations really depend on the kind of game you'd like to build and the number of concurrent clients you'll have. The framework is still being tested and evolved to support as many scenarios as possible.

    Cheers!



  • Thanks for the detailed answer!

    AFAIK these platforms you mentioned will provide servers and resources to host your game. As Colyseus is just a networking framework, it also doesn't provide any kind of game logic out of the box. You'd need to implement everything by yourself.

    Right, both platforms are also social networks, and I don't need that. (Though BYOND doesn't host the servers.) A networking framework is exactly what I'm looking for.

    This works great if your game state is not too big.

    How big is too big?
    I've seen the splitting and filtering views feature. It seems like a must-have for a networking framework, not only for performance, but also for cheating prevention purposes.

    Currently, we haven't seen a use case for this. Most games need to have multiple sessions, and matchmaking comes along with it.

    My (hypothetical) use case is a ss13-like: every server uses their own fork of the game code with minor tweaks, and the servers can have up to a hundred players and are barely ever full.

    Not at the moment. I believe client-side prediction is not easily pluggable in a way that the framework abstract everything for you.

    Wait, do you run the game code on the client at all?

    Client-side prediction can depend on the game, but all games could benefit from changing the local state immediately. And many games aren't performance-bound on the client by the size of the local game state and can handle recalculating several game states every time the server sends something unexpected. Right?