INTRODUCING SHARD

Shard is a from-scratch, community-driven reimplementation of the Hytale server, written in C#. That's the whole idea, and it's an ambitious one. We aren't wrapping the original, and we aren't proxying or patching it either. We're rebuilding it as a new codebase that speaks the same native language as the client.

We've been heads-down on this for the past several weeks without saying much publicly. This post is us finally coming up for air, and we get to open with the milestone we'd been working toward: a player can now connect to a Shard server and stand in a world it generated from nothing.

Up front: Shard is an independent community experiment and an extremely early proof of concept. It is not an official Hytale server implementation or a replacement for the Java server, and nothing about it is a roadmap commitment. Almost everything under the surface will change as we learn.

It's strange to be back in the Hytale world and see it so stripped down, but that means we're making progress. The rest of this post covers how the pieces came together, and why we're about to slow down on purpose.

Why are we even doing this?

It all started with Simon saying that a community-built C# server could be one hell of a comeback story. A couple of us said that sounded like fun, and that was enough. Here's how he put it:

Honestly, one of the things that hurt the original Hytale was the full client and server rewrite that everything else had to wait on. It became a huge distraction and a big part of why the game got cancelled. We can't repeat that.

This effort is the opposite. Our team keeps shipping the Java server while the community explores C# in parallel, without blocking us. We'll help where we can. It's R&D, not a promise, but if the community reaches parity, it could open some very interesting doors. Big could. No deadlines, no promises, but that's the dream.

Shared source lets us keep building while the community attempts something extraordinary. Neither side could do this alone. Show us how far this can go.

Why are we still doing it? It's become a passion project for our small group of rather dedicated developers, and an adventure none of us really expected to take on. It's had us learning a lot and teaching each other things that are foreign to some of us but native to others. And what we're building could genuinely be useful to Hytale and its community down the road.

The road to standing on a block

Speaking the client's language: Nothing happens until the client and server complete the login handshake, and that handshake leaves no room for "close enough." Every field has to be exactly correct and every packet has to match exactly, or the client simply says no, and moves on. Clearing that handshake was the first time a real Hytale client accepted Shard as a server.

The asset stream: A connected client immediately expects to be handed a huge amount of data: block types, items, weather, environments, sounds, models, and much much more. Each of these assets has a precise format with little to no room for deviations, and the pipeline we built delivers the default asset data the client expects, in the formats it expects. There was no single hard problem in there, just an enormous number of small, precise ones. The kind of work that didn't make for a good screenshot, but set us up for where we are now.

Getting a player through the door: With assets flowing, we turned to the join sequence: creating a player the client will accept and spawn. Meanwhile, the developers working on our entity component system (ECS) were shaping the architecture the rest of the server will build on, and this one player exposed a lot of unforgiving edge cases. That's part of why we're going to need to slow down.

Building the ground to stand on: A player by itself means nothing without a world to stand in, and giving it one meant even more theory work. With Hytale's world generation heading toward Cubic Chunks and World Generation V2, the direction laid out publicly in The Future of World Generation, we decided to make that our default from day one. That choice creates plenty of its own problems, but it beats building Shard's first version on a world structure that's expected to change.

The result, for now, is stone. It's not much of a world yet, but Shard generated it, got it to the client, and put a player standing in it.

Why we're not celebrating for long

The purpose of this entire first phase was to answer a single question: can a C# server carry a real client all the way to being in the world? The answer is now yes. The full path works, but only under the narrow conditions we built it for, and there are problems.

Reaching the world is a proof of concept, not a foundation.

A meaningful share of what carried us here is scaffolding, shortcuts, hardcoded assumptions, and systems assembled in whatever place had the data we needed at the time. Each rough edge in the world we can now explore points to a corner we cut to get into the world faster, and those need fixing before we build anything else on top of them.

So rather than pressing forward into biomes, props, and the world features that make for pretty screenshots and flashy videos, we're heading back down to the foundations. It'll be slower, with fewer screenshots, but we'd rather end up with a server people might one day rely on than a demo that impresses once.

Future Plans

Contributors

We're not opening up to more contributors just yet. We want a solid foundation in place first, and once it's set and we can support new developers properly, we'll say so in a future devlog. The code isn't public yet either. Opening it up is part of the same conversation as opening up to contributors, and we'll cover both there.

DevLogs

These posts are going to be the primary way we communicate with everyone. We don't have a set schedule yet, so we'll post whenever we have something to show & let everyone know what we're doing.

What's Next

The near future is all internal work: the systems under the surface. We're still at the very start of this, and there's a lot left to do.

Our next post will go over more of the tech we use & why we use it. We'll see everyone then, likely with fewer screenshots, but with a much better server underneath the words.