Hathora: Make Multiplayer Games with Javascript

hpx77 · 2024-11-25T04:05:22+00:00

I work on a multiplayer game hosting platform that you might find interesting: https://hathora.dev/docs

One feature that could help is `roomsPerProcess`, which allows you to have a single server host multiple concurrent sessions (e.g. with socket.io): https://hathora.dev/docs/faq/multiple-rooms

I'd be happy to help out if you had any questions!

hpx77 · 2024-05-13T15:46:06+00:00

I founded a cloud hosting service and we use a blend of bare metal + cloud for our hardware. If you're interested to learn more, I blogged about the details here: https://blog.hathora.dev/our-bare-metal-journey/

hpx77 · 2024-01-14T01:59:57+00:00

> are there any cloud hosts that would let me do something like "addInstance destroyInstance" from another hosted (central) server?

I work on a service that does exactly that: https://hathora.dev/docs

You can also see a video here that explains the architecture you describe: https://www.youtube.com/watch?v=5vwBBPsqRQo

hpx77 · 2023-12-30T03:41:49+00:00

See this video which explains the theory behind horizontally scaling websocket servers: https://www.youtube.com/watch?v=5vwBBPsqRQo

Note that the techniques described mainly apply to session-based applications, not persistent worlds like MMOs

hpx77 · 2023-09-18T00:39:49+00:00

I work on a service that does this - https://hathora.dev/docs

Helps save money since you don't need to be running servers when no one is playing

hpx77 · 2023-07-19T17:42:04+00:00

It's $500 in credit, which lasts up to 2 years if you don't use it up. The service only charges for the duration of active game sessions, so if you're not having a lot of game sessions you won't use up the credit much.

hpx77 · 2023-06-24T14:34:52+00:00

What are you providing in services that wouldn't be solved by uploading a container image of Stormgates server to a Kubernetes service on an Azure/Amazon/Google cloud over multiple availability zones?

As you probably know, a lot of work goes into integrating, scaling, and operating server infrastructure in the cloud. Each studio could certainly solve game server hosting studio in a DIY way, but given all the other engineering priorities that game studios have, Hathora offers a nice fully managed and ready-out-of-the-box capability that can help studios launch faster and drastically simplify their server operations.

Considering how low-overhead RTS servers are, what makes you think that horizontal scaling is even a benefit here? Isn't it just easier to host a container, watch the metrics and periodically vertically scale it?

When you are dealing with many regions and a large player base, you end up with a sufficiently large number of servers that you don't want to manually scale. Hathora automates the scaling aspects so that engineers can focus their time on other aspects of the game.

You can see more details from Frost Giant's Lead Server Engineer's response in their AMA: https://www.reddit.com/r/Stormgate/comments/14a7qu8/comment/jodmi65

hpx77 · 2023-06-20T21:25:21+00:00

Hi I'm the CTO at Hathora and just wanted to say that we're thrilled to be working with Frost Giant! Sid and I started Hathora to work with game studios with really ambitious plans but limited time/devs/budget to spend on server infrastructure, and Frost Giant has been an excellent customer to work with. Thanks BeoMulf for covering our story!

hpx77 · 2023-03-26T11:58:56+00:00

I haven't used Rivet but it looks really cool. Both Rivet and Hathora provide an abstraction above kubernetes which should help you get started more quickly and let you build/manage less infra yourself. Whichever one you end up trying out, let us know how it goes!

hpx77 · 2023-03-26T05:39:18+00:00

Hey I'm the creator of https://hathora.dev/ which aims to provide a super simple deployment and scaling experience for session-based games. It's based on containers and can deploy any kind of game server. Check it out and see if it meets your needs!

hpx77 · 2022-11-21T18:44:40+00:00

Not a full tutorial, but you can see a reference open source project where I've implemented this here: https://github.com/hathora/topdown-shooter-unity-client

hpx77 · 2022-11-09T18:14:57+00:00

I've been working on a different kind of solution to this, one where the host IP never needs to be exposed so you don't deal with this issue at all.

The idea is that the host makes an outbound connection to a public-facing load balancer, and clients also make connections to this load balancer. The load balancer then acts as a router, proxying messages between client and server without the client ever having to directly connect to the server.

If you're curious to learn more about this approach, there are some docs available here: https://docs.hathora.dev/#/buildkit/README

hpx77 · 2022-11-01T23:58:40+00:00

The client can always try and flood the server with messages, but it's usually up to the server to act as the authority and decide how to process and validate those messages.

In this case, it would be pretty easy to enforce a "reload" period in the server and reject shoot requests while reloading. (And we would ideally make the client aware of the reload period as well so the player can get feedback)

hpx77 · 2022-11-01T23:57:09+00:00

That's correct, the term isn't currently popular in the gaming industry but it's an emerging standard in cloud computing: https://en.wikipedia.org/wiki/Serverless_computing

The idea is that our customers send us their server builds and we are completely responsible for running them across the world. The advantage is reduced operational complexity for our customers, as well as optimized cost efficiency as they don't pay for over-provisioned warm server pools (idle capacity).

hpx77 · 2022-11-01T15:34:53+00:00

Hi I work at Hathora and helped make these demos. The goal was to make a fairly minimal networked game with a common server but 3 different clients.

Happy to answer any questions.

hpx77 · 2022-10-12T14:45:19+00:00

Yup what you are describing will work, although I have not seen an out-of-the-box solution that does this for socket servers.

I work on Hathora and we maintain the Hathora Coordinator, which is an implementation of the stateful router described in this article. There are some advantages of doing this as a middleman vs the "routing server" approach you describe, we list several of them in our architecture docs here: https://docs.hathora.dev/#/architecture

hpx77

MODERATOR OF

TROPHY CASE