Blockbase | Devpost

Inspiration

If you're anything like me, your passion for computer science and software engineering might have come from video games. For me, that video game was Minecraft.

To build something amazing and impressive, collaboration is a must, especially in engineering. For software engineers, this is facilitated through Git, which allows version control, easy feature-rolling, and collaboration.

Minecraft has an active community of over 170 million builders, yet they still don't have anything remotely similar to Git or GitHub to collaborate on large-scale builds without impeding other people's work. With that being said, I decided to build Blockbase, a Minecraft-native development environment that introduces git-like commands directly within the Minecraft chat!

What it does

Behind the scenes, Blockbase tracks block-level changes in your world, i.e. what was placed, broken, or modified. With that, it turns those into commits towards a web interface you can browse in a GitHub-style. You can visually diff your build in place inside Minecraft: press a key to toggle a “Diff” view, and Blockbase overlays green blocks where you’ve added things and red blocks where you removed them, relative to your last commit. The web app mirrors this history by showing repositories, commits, READMEs, and per-commit added/removed blocks, so your Minecraft builds have the same tooling you’d expect from a modern software project.

How we built it

On the Minecraft side, Blockbase is a Fabric mod (1.18.2) written in Java. It hooks into the game using Mixin and event listeners so it can observe when blocks are placed, broken, or have their state changed. Those events are turned into BlockChange objects, serialized to JSON, staged, and then written out as commit files when you run /bb commit.

I implemented Git-like commands using Minecraft’s Brigadier command system (/bb init, /bb add ., /bb commit, /bb reset --hard, /bb push, etc.). For visual diffing, I added a client-side renderer and HUD overlay that draw translucent colored boxes in your current world, without ever actually changing blocks on disk.

For the backend, I used FastAPI + SQLite as a lightweight remote for Blockbase. The mod uses OkHttp to talk to the API, pushing commits to endpoints such as /api/repos/{id}/commits. The backend stores repository metadata, commits, and the raw change data in a single SQLite file, which the web UI can query. The frontend is built with Next.js and Tailwind CSS. It behaves like a mini GitHub for Blockbase: a landing page, a repo list, repo detail pages with README editing, and commit detail pages that fetch real commit data from the API and show what blocks were added or removed, complete with Minecraft-style icons.

Challenges we ran into

One of the hardest parts was making Minecraft behave like a version-controlled workspace without breaking the game. I had to decide what counts as a “change” (e.g., avoiding noisy blocks like doors flipping open and closed every tick), how far from the player we should track activity, and how to make reset --hard safely roll the world back to a previous commit by restoring old block states. Getting that rollback logic right required careful handling of placed/broken/modified blocks and robust JSON parsing of commit files.

Accomplishments that we're proud of

We’re proud that Blockbase actually feels like Git inside Minecraft, and not really just a mockup. You can start a new world, initialize a repo, commit your build, reset it, push to a remote, and browse that history from a web interface, which are all using familiar Git-style commands and workflows. The in-game diffing, with green and red overlays toggled by a keybind, gives a genuinely useful spatial intuition for “what changed” between versions of a build. I can genuinely use this for my future Minecraft builds.

What we learned

I learned a lot about how Minecraft’s internal systems (blocks, chunk updates, rendering, input, and commands) can be bent into something that looks like a developer tool. Working at the block-state level forced me to think about version control in three dimensions.

On the backend and frontend side, I got practice treating a game as a first-class client of a web API. Designing endpoints that both a Minecraft mod and a React/Next.js frontend could use cleanly, and keeping the data model consistent across Java, Python, and TypeScript, reinforced how important clear contracts and schemas are. I also learned some very practical lessons about debugging cross‑stack issues: a “bad” commit message or timestamp in the UI often meant a tiny mismatch in how strings or dates were serialized earlier in the pipeline.

What's next for Blockbase

Next, I’d like to round out the Git feature set: branches, tags, and maybe even pull requests for worlds. That would mean adding proper branching semantics to the mod, supporting multiple heads in the backend, and visualizing branches and merges in the web UI. I’d also love to expand collaboration with multi‑user support and authentication so multiple players can push to the same remote and see each other’s work. On the visualization side, there’s a lot of room to explore richer 3D diffing and history playback: time‑scrubbing through commits inside Minecraft, ghosting entire previous builds, or letting teammates “annotate” areas of a world like code review comments. Longer term, Blockbase could become a foundation for AI‑assisted building, where models can propose or generate changes as commits that you can review and apply, just like a pull request for your Minecraft world.