Joining Jollywhoppers: On Collaboration, Minecraft Mods, and Finding Your People

I've officially become a member of Jollywhoppers. Which sounds either very exciting or completely meaningless depending on whether you know what Jollywhoppers is, so let me back up a bit.

Recently, I started building a Minecraft mod. Nothing revolutionary – just a Fabric mod that connects Minecraft to the AT Protocol. I called it atproto-connect, hosted it on Tangled , and figured maybe a handful of people would find it interesting. The premise was simple: what if your Minecraft achievements could post to Bluesky? What if the boundary between your game world and your social network was more permeable?

Turns out, other people thought this was interesting too. Specifically, Xan thought it was interesting. And somewhere between "hey, this is neat" and "we should actually do something with this," atproto-connect stopped being just my project and started becoming something collaborative. Which is how I ended up joining Jollywhoppers properly, rather than just being an occasional contributor orbiting the edges.

What Jollywhoppers Actually Is

Jollywhoppers is... well, it's a bit hard to explain succinctly, honestly. On the surface, it's a collective building things with the AT Protocol. But that description makes it sound more formal than it actually is. In practice, it's a group of people who got excited about what decentralised social networking could be and decided to build infrastructure for it.

The flagship project is Witchsky – a fork of Bluesky's social app . It's their main thing, the project that defines what Jollywhoppers is to most people who've heard of us. I'm not directly involved with Witchsky development (that's very much Xan's domain), but it provides the context for everything else we're building.

My mod – now being renamed to SocialSync – is much newer to the collective. I've only been actively developing it for just over a week, really. It's still a Minecraft mod that connects to ATProto, still about posting achievements and thinking about how game data could be portable and verifiable. But now it's part of a broader ecosystem rather than a standalone experiment.

There are plans for an AppView for leaderboards, proper API integration, all sorts of ambitious infrastructure. Whether we actually build all of that remains to be seen. But that's sort of the point – when you're working with a protocol designed for decentralisation, you might as well think big.

How I Got Here

The path to actually joining wasn't dramatic. I asked Xan if I could join, and they said yes. That was it. No formal interviews, no lengthy application process, no gradual organic evolution from contributor to member. Just a straightforward question and a straightforward answer.

Which, honestly, is very much in keeping with how a lot of AT Protocol projects seem to work. The boundaries between "interested person," "contributor," and "member" are fuzzy enough that sometimes you just ask directly and skip the ambiguity entirely.

Though I suppose moving atproto-connect from my personal Tangled repository to the Jollywhoppers organisation made it feel more official. That was the point where it stopped being mine and started being ours. Which felt significant at the time, and still does, honestly. I'm not possessive about projects – I'd rather they grow and improve with other people's input than stay perfectly under my control – but there's still something quietly momentous about handing over stewardship.

The website revitalisation has been the main focus of my work with Jollywhoppers, actually. Xan sent me a mockup of their vision for the site, and I'm building it out in SvelteKit because that's what I know and it's what my own website uses. Which means I'm now maintaining two websites with very similar tech stacks, which is either efficient or setting myself up for confused merge conflicts down the line. We'll see.

The repository structure is interesting – I split my usage between Tangled and GitHub depending on the project, but all of Jollywhoppers' repositories live on Tangled at tangled.org/jollywhoppers.com . Which makes sense given the collective's focus on AT Protocol infrastructure.

What This Actually Means

Membership in Jollywhoppers isn't just symbolic, even though I've only been properly involved for a short time. It's changed how I think about the projects I'm working on. When atproto-connect was mine, I could make decisions quickly – change the license, refactor the codebase, add features on a whim. Now there's actual collaboration involved, which means more discussion, more consideration of how changes affect other people's work, more thinking about the project's direction rather than just my immediate goals.

The website work has been the main focus, which is fine – I know web development, I'm comfortable with SvelteKit, and it's tangible progress on something that matters for the collective's visibility. The mod development is newer and still finding its shape. Just over a week in, and I'm still figuring out the architecture, still learning Kotlin properly, still thinking about how to structure things so they're maintainable when other people might want to contribute.

It's also changed the scope of what I'm building, or at least what I'm thinking about building. The AppView for leaderboards, for instance – that's not something I would have considered solo. It's infrastructure work, the kind of thing that requires sustained effort and coordination. But as part of Jollywhoppers, it makes sense. We're not just building isolated projects; we're building an ecosystem. Or at least the foundations of one.

And there's the social dimension, which I'm still adjusting to. I'm used to working solo, or at most collaborating loosely with one or two other people. Jollywhoppers is more structured than that, but not in a corporate way – it's structured the way open source collectives tend to be structured, which is to say organized chaos held together by shared enthusiasm and Git repositories.

The AT Protocol Context

Part of what makes Jollywhoppers work is that we're all invested in the AT Protocol specifically. Not just as a technical curiosity, but as a genuine attempt to build better infrastructure for social networking. I've been working with ATProto for a while now – my blog runs on it, I've built importers and tools and integrations – but Jollywhoppers is the first time I've worked on something collaborative within the ecosystem.

And the ecosystem matters here. Witchsky is built on ATProto, forking Bluesky's social app to experiment with what's possible within the protocol. The Minecraft mod work – still very new, still finding its direction – is exploring a different angle: how game data could integrate with decentralised social protocols. When you're building with ATProto, you're not building for one platform or one company. You're building for a protocol, which means what you make can be used across different implementations, different clients, different contexts.

That portability is what drew me to the protocol in the first place. The idea that your data isn't owned by a platform, that identity and content and relationships can be portable and verifiable – that feels worth building on.

What Comes Next

The immediate work is finishing the website refresh, which is coming along well. The skeleton is there, the design is taking shape, and it's starting to feel like a proper representation of what Jollywhoppers is. Beyond that, there's stabilizing SocialSync – getting the fundamentals right before thinking about ambitious features like AppViews. And there's documentation, because building cool things is meaningless if nobody knows how to use them.

Longer term? I genuinely don't know. Witchsky will continue being Jollywhoppers' flagship project. SocialSync might grow into something significant, or it might remain a small experiment in connecting games to decentralised protocols. Both outcomes are fine, honestly. What matters is that we're building things we think are worth building, in ways that align with the values that drew us to decentralised protocols in the first place.

I'm also still figuring out what membership means for my other work. My personal projects, my blog, my other experiments with ATProto – those don't stop just because I'm now collaborating on something bigger. If anything, Jollywhoppers has made me think more carefully about how different projects inform each other, how being part of a collective changes the context in which you work.

On Finding Your People

Here's the thing that I didn't expect: joining Jollywhoppers has made me feel less isolated in my weird technical interests. I've spent a lot of time working alone on projects that nobody else really cared about – importing scrobbles, building blog infrastructure, mucking about with APIs and protocols because they're interesting rather than because there's obvious practical value. And that's been fine. I'm quite comfortable working solo.

But there's something different about working with people who are equally invested in the same weird technical problems you are. Who understand why decentralised identity matters, why portable data is important, why building alternatives to centralised platforms is more interesting than it sounds. It's not that I needed validation, exactly, but it turns out having collaborators who share your enthusiasm makes the work more enjoyable.

The Practical Reality

I should probably be honest about what this doesn't change. I'm still 20, still figuring things out, still dealing with college work and the general chaos of existing. Jollywhoppers is important to me, but it's not my entire identity or my only project. I'm not suddenly a professional developer or a community leader or anything dramatic like that. I'm just someone who builds things with code, and now some of those things are collaborative rather than solo.

The website work is familiar territory – I know SvelteKit, I know TailwindCSS , I know how to make things look decent. But coordinating with other people's vision for the design adds complexity. The mod work is newer and still finding its footing. Kotlin is still relatively new to me (I've only been actively developing SocialSync for just over a week). The AT Protocol specification is still evolving, which means keeping up with changes and figuring out how they affect what we're building.

And there's still the question of scope management. It's very easy, when you're building something ambitious within a new protocol, to keep expanding the scope until you've promised to solve every problem anyone has ever had with Minecraft multiplayer or social networking or data portability. We're trying to be disciplined about this. Build the core functionality first. Make it stable. Then think about what comes next.

Why This Matters

I keep coming back to the question of why any of this matters. Why join a collective that's forking Bluesky? Why build a Minecraft mod that posts to a decentralised social protocol? Why spend time on website design for a small group most people haven't heard of?

Part of it is purely technical interest. The problems are fascinating. How do you fork a social app in a way that's meaningful? How do you handle authentication between game clients and AT Protocol services? How do you build infrastructure that's decentralised but still performs well enough for real-time interactions?

But part of it is also ideological, in a way I'm still articulating to myself. I believe in decentralised systems. I believe in data portability, in identity that isn't owned by platforms, in protocols over products. And Jollywhoppers is one small attempt to extend those principles – Witchsky by exploring what's possible with social apps, SocialSync by thinking about gaming integration, the website by making it all visible and accessible.

Will it matter in the grand scheme of things? Probably not. We're a small collective working on projects within an emerging protocol. But maybe that's fine. Maybe the point isn't to change everything, just to build something good, with people you enjoy working with, using protocols you believe in.

Reflections

Looking back at the past couple of weeks – from building atproto-connect solo to joining Jollywhoppers properly – the main thing that's changed is context. Not confidence exactly (I'm still figuring things out constantly), but understanding that the work fits into something larger. That connecting games to decentralised social protocols isn't just a solo experiment but something that could be part of an ecosystem.

I'm still the same person who spent months tracking lunar phases without any particular spiritual framework before finding paganism. Still the same person who builds things compulsively, who can't leave well enough alone, who thinks the details matter even when nobody else will notice them. But now some of that compulsive building is happening collaboratively, within a structure that gives it more possibility.

The yew has been watered, as I said in another context entirely. The work continues. The projects grow. And I've found a group of people who think this particular kind of work – whether it's forking social apps, building bridges between games and protocols, or making websites that explain what we're doing – is worth doing.