Erik Reitbauer, 17, software developer from Austria.

Clay turns a folder of Markdown files into a fast, searchable documentation site that readers, search engines and AI agents can all use. It is one npm package, clay-doc, built on Nuxt and Vue: a repository installs it, writes its pages in docs/, and clay build writes a static site that runs on any host, such as GitHub Pages. There is no theme to set up and no code to write.

Clay documents itself: the live demo is Clay's own documentation, built with Clay.

Capabilities

• Pre-rendered pages that load fast, work without JavaScript and fit small screens.
• Full-text search across every page and section, grouped by page, typos forgiven.
• Clay Flavored Markdown: tabs, steps, cards, details, badges, math, diagrams, file trees, prompts, videos and embeds, written in plain Markdown, plus snippets and variables to write a text once.
• OpenAPI pages with request cells to try an endpoint right on the page.
• Ready for AI: every page as Markdown, llms.txt, a page menu to open a page in ChatGPT or Claude, and commands coding agents understand.
• Versions and translations, with switchers that keep the page you are reading, and redirects for pages that moved.
• Your look: colors, corners and fonts in clay.yaml, light and dark themes.
• Analytics without cookies through Plausible, Umami or GoatCounter, including searches that found nothing and a "Was this page helpful?" question.
• SEO: canonical links, structured data, a sitemap and a social image for every page, in any script and with emoji.
• Checks for broken links, missing sections and config typos; --strict turns them into build failures.

How It Works

Clay lives in the repository as a dev dependency. Everything it needs comes from two places: the Markdown in docs/ and one clay.yaml.

.
├── docs/                    # The pages (Markdown)
│   ├── index.md
│   ├── index.de.md          # The same page in German
│   ├── _snippets/           # Text to reuse, not pages of their own
│   └── guides/
│       └── setup.md
├── clay.yaml                # Configuration; only the title is required
└── package.json             # clay-doc as a dev dependency

At build time Clay loads the docs, checks every link and setting, turns the Markdown into sanitized HTML and pre-renders each page with its Nuxt app. The output in publish/public holds one HTML file per page, the search index, sitemap.xml, robots.txt, llms.txt and a Markdown copy of every page.

Commands

Configuration

Only title is required. A larger clay.yaml might look like this:

title: "My Project"
favicon: "logo.svg"
baseURL: "/my-project/"
siteURL: "https://my-org.github.io"
editURL: "https://github.com/my-org/my-project/edit/main/docs/"
version: "5.x"
languages: ["en", "de"]

navbar:
  logo: "logo.svg"
  source:
    name: "GitHub"
    icon: "fa-brands fa-github"
    link: "https://github.com/my-org/my-project"

analytics:
  goatcounter:
    code: "my-project"
  feedback: true

openapi:
  - spec: openapi/petstore.yaml
    title: "Petstore API"

Quick Start

In the repository that holds the docs (Node.js 22.22.3 or newer):

npm install --save-dev clay-doc
echo 'title: "My Project"' > clay.yaml
mkdir docs && echo '# Hello, Clay' > docs/index.md
npx clay dev

From Clay Oven to one package

Clay started as a prebuilt frontend that read the docs at runtime, filled in by Clay Oven, a separate Go CLI that scanned docs/ and bundled the site. Clay 2 replaced both with the clay-doc package, which pre-renders every page at build time, so the browser no longer renders Markdown. Clay 3 to 5 added index pages, versions in folders of their own, components, agent support, themes, analytics, OpenAPI pages and the rest of the command line.

Repositories

• clay, the package: the Nuxt app and the clay command line.
• clay-example-repo, Clay's documentation, built with Clay and using every feature.

Orchestration for a fleet of Minecraft agents that build a large schematic together. An operator uploads a schematic, picks the agents to work it, and Osmium splits it into segments and hands each agent its own slice. The dashboard shows what the fleet is doing: blocks left, throughput, the traffic every host moves, what needs attention, and what happened.

Agents can be sent anywhere by clicking the map or the 3D view. They walk there, or fly where the server allows it, and build what they are given one course at a time: stairs the right way round, slabs on the right half, doors hinged on the side they were drawn on.

Modules

The one idea worth knowing

Osmium never holds Minecraft credentials, and never performs the login.

The backend sends a host a setup_agent command; that host logs the account in by whatever means it prefers and reports back only the resulting username and UUID. A full database dump therefore reveals which accounts you run, not the ability to run them.

That constraint shapes everything else: how agents are addressed, why hosts dial out instead of being connected to, and why a host being unreachable makes an agent's state unknown rather than offline.

FLEET_CONNECTIVITY.md is the design document, credential custody, the wire protocol, liveness, chat, and the alternatives that were rejected and why.

Running it locally

Needs JDK 25, Node 24 and Docker.

# 1. Postgres
docker compose -f backend/docker-compose.yml up -d

# 2. Backend on :8080
cd backend && ./gradlew bootRun          # gradlew.bat on Windows

# 3. Frontend on :5173, proxying /api to the backend
cd frontend && npm install && npm run dev

# 4. Optional: a mock host, once you have registered one and copied its token
cd backend && OSMIUM_HOST_TOKEN=osm_host_1_… ./gradlew mockHost

The mock host speaks the real protocol over the real socket, it connects, reports agents, telemetry and chat, fetches segments and places blocks, so the whole pipeline can be exercised without a Minecraft account. It is a development convenience, not a stand-in for the host program.

Sign in with admin / admin. Those are development defaults and are seeded only while the users table is empty, override OSMIUM_BOOTSTRAP_USERNAME / OSMIUM_BOOTSTRAP_PASSWORD, and OSMIUM_JWT_SECRET, before running this anywhere real.

Forkcast is a web application that digitizes and simplifies meal planning. Instead of juggling paper lists, it combines a drag-and-drop weekly calendar with a smart shopping list, recipe discovery, and a small social layer around friends.

Features

Meal Planner & Calendar

• Interactive weekly calendar as the core of the app.
• Drag & drop recipes onto a weekday, categorized as breakfast, lunch, dinner, or a free-text label.
• Portions scale ingredient amounts to the number of people.

Smart Shopping List

• Generated automatically from the weekly plan.
• Identical ingredients across recipes (e.g. onions) are merged and summed.
• Stock check: tick off or reduce quantities for items already at home.

Discovery & Social

• Home page acts as an inspiration feed with a daily highlight.
• Friend network: add friends by username, send/accept/decline requests.
• Privacy: each user chooses whether their weekly plan is public or private.

Recipes & Personalization

• Spoonacular API as recipe source, with detailed ingredients and nutrition.
• Search with filters, favorites, and per-recipe ratings.
• Allergy / dietary filters applied to recommendations.
• 9 UI languages including right-to-left (Arabic, Hebrew).

Architecture

Monorepo with two independently deployed apps:

The frontend is a static SPA: it talks to the backend REST API at /api, holds the JWT in sessionStorage, and renders the dashboard client-side. The backend owns auth, the SQLite database, recipe caching from Spoonacular, and email (verification / password reset).

Quick Start

Run the backend and frontend in two terminals:

# Backend (REST API on :3000)
cd backend
cp example.env .env        # fill in JWT_SECRET, SPOONACULAR_API_KEY, ...
npm install && npm start

# Frontend (Nuxt dev server on :8080)
cd frontend
npm install
npm run dev -- --port 8080

Team

Kerimcan Yagci, Lukas Grünzweil, Erik Reitbauer and Nico Haider, as a summer project in school.

Backbone is a powerful and flexible plugin for Spigot-based Minecraft servers. Its core idea: write, test, and update server logic on a live server without restarts, dramatically speeding up the development lifecycle.

Whether you are an admin adding custom features with simple scripts or a developer prototyping new ideas, Backbone gives you the tools to be more productive.

Features

• Hot-Loadable Scripts: Write and reload Kotlin scripts without restarting the server.
• Advanced Scripting: Inter-script imports, Maven dependencies, and custom compiler options.
• Event System: A custom event bus that complements Bukkit's, with more control inside scripts.
• Command Framework: A simple but powerful system to create commands directly from scripts.
• Storage Abstraction: Flexible storage with SQLite databases and typed configuration files.
• GUI Framework: A declarative framework for building interactive inventories.
• Custom Items & Entities: Stateful items with abilities and custom entities via the goals API.
• Display Entity Rendering: Create custom visuals in the world.
• PlaceholderAPI Integration, HTTP Client DSL, memory-leak detection, and much more.

Getting Started

1. Download the latest release and drop the .jar into your server's plugins directory.
2. Start the server, Backbone generates its folders automatically.
3. Write custom logic in .bb.kts script files inside scripts/.

Requires Minecraft Java 1.21.11+, a Spigot-based server (Spigot, Paper), and Java 17+.

Scripting Example

Every script uses the lifecycle DSL for hooks and event listeners:

lifecycle {
    // 'sustained' properties persist across script reloads.
    var counter by sustained(0)

    onLoad {
        println("Script loaded! Counter: $counter")
    }

    // Fires every server tick while the script is enabled.
    listener<TickEvent> { event ->
        counter++
        if (counter % 20 == 0) {
            Backbone.PLUGIN.server.onlinePlayers
                .forEach { it.sendMessage("Count: $counter") }
        }
    }
}

Scripts can pull Maven dependencies with @DependsOn, share code through .bbu.kts utility scripts, define commands, build GUIs, and talk to each other through inter-script messaging, all hot-reloadable with /bb scripting reload.

Helix is a QOL Mod that aims to improve your experience by adding various features. Helix is free and open source, forever.

Installation

Helix requires the Kotlin language adapter and the Fabric API to work correctly.

How to install, step by step

• Download the latest release of Helix, the matching Fabric API and Kotlin language adapter
• Put all 3 mods in your mods folder
• Make sure you have the correct java version installed (17)
• Make sure you have the fabric loader installed
• Launch the fabric loader
• Have fun!

Accent colours

Rgb, orange, red, green, yellow, pink, purple and blue.

Themes

Dark and light.

In-Game features

• Crystal Optimizer Optimized the placing and breaking of crystals clientside to improve crystal speed (removing broken crystals on the client...)
• Block Outline Changes your block outline and adds optional entity outlines
• Armor Hud Shows you your armor on the screen without having to open your inventory
• Autosprint Presses the sprint key for you
• Better Arm Changes the rendering of your In-Game hand
• Coordinates Shows you your coordinates in the world
• Cosmetics Render cosmetics clientside, for free
• Directions Shows in what direction you are facing
• Fps Display Shows your current Fps
• Fullbright See in the dark
• Hotbar Changes several status bars to literal bars
• Keystrokes Shows what keys are being pressed
• Nametags See your own nametag and add information to it
• No Armor Hides your armor clientside
• No Render Disables the rendering of certain things
• Ping Display Shows your current ping
• Chat Format Create gradients without leaving Minecraft. Can also solve simple math, for example <solve>1+2*(27-5)/5<solve>

Commands

• /helix Opens the main UI
• /gmc player Puts you or the optionally specified player in creative mode (only works if you have permission on the server since we are just redirecting commands)
• /gms player Puts you or the optionally specified player in survival mode (only works if you have permission on the server since we are just redirecting commands)
• /gma player Puts you or the optionally specified player in adventure mode (only works if you have permission on the server since we are just redirecting commands)
• /gmsp player Puts you or the optionally specified player in spectator mode (only works if you have permission on the server since we are just redirecting commands)

Discord Presence

Shows some information about the server or world you are on to your friends on discord

For Developers and Server Owners

The following example code can be used to block modules from being used on your server. In the future, there may be more options for configuring the mod via the server.

Json Structure for the payload

This is the structure to use in the payload of the message sent to the player. Invalid json and incorrect module ids will be ignored. You can find the module ids in the respective modules. The ids can always be found in the header of the module and will always be in the following scheme: moduleName.

{
  "disabled": [
    "armorHud",
    "autoSprint"
  ]
}

Sending the configuration json in your plugin

This code can be put for example in the onJoin listener. Once disabled, modules stay disabled until the player rejoins the server. Then they need to be disabled again.

<player>.sendPluginMessage(<plugin-instance>, "helix:config",
     <json-payload>.toByteArray()
);