LastEra Devlog #0 — Why Rebuild Everything

Building a Minecraft educational server from scratch: lore, pedagogy, and the chaos that made it worth it.

The Spark: One Server, Three Teams, One War

The last session ended like this: three teams, a scoreboard, and students aged 7 to 16 fighting over first place with an intensity I had not anticipated.

District Y in the lead with 80 points. District S at 35. District C at 20. And in the room, kids negotiating alliances, accusing teammates of sabotage, filing official complaints about rules I had invented the day before.

That moment convinced me to rebuild everything.

Why This Server Exists

I teach coding and robotics at a youth center in Brussels. Scratch, Python, Godot, micro:bit, LEGO Spike Prime, students aged 7 to 16. The recurring problem with this age range is entry-level motivation: how do you make a 9-year-old understand that learning to code is useful before they have written a single line?

Minecraft solves this sideways. The students already know the game. The world belongs to them. If I build the course inside it, I am not starting from zero in terms of engagement.

The original server was a first iteration, built fast for a final session. Minimal lore, improvised missions, manual point tracking. It worked far beyond my expectations, which means the foundations deserve a real build.

How Missions Are Adapted by Age

Main constraint: 7-year-olds and 16-year-olds in the same game space. That is not the same relationship to play, reading, frustration, or competition.

The solution: multi-entry missions. The same quest can be completed in different ways depending on level. Younger students follow visual and spatial instructions in-game. Older students access missions involving logic, CC:Tweaked Lua scripts, or more complex resource constraints.

The district points system creates collective rather than individual competition. An 8-year-old completing a basic mission contributes to the same total as their 14-year-old teammate who solved a redstone puzzle. No one is dead weight.

Concrete Results

What surprised me most: engagement lasted beyond the session. Students kept discussing strategies between classes. Some asked whether the server would stay accessible during holidays. One group spontaneously created a coordination channel outside class hours.

For kids who were rolling their eyes when I opened a code editor two months earlier, that is a meaningful signal.

The final ranking was not the objective. But it revealed something useful: inter-district competition generated more intra-district collaboration than any cooperative activity I had explicitly designed for that purpose.

Deep Dive: What the Server Was Technically

The modpack

Deliberately lightweight stack: CC:Tweaked for Lua scripting, Create for industrial mechanics, Easy NPC for quest characters, Cadmus for district territory management. Nothing heavy. The server had to run on a modest VPS without latency becoming a pedagogical problem.

Infrastructure

The server runs as a systemd service with Restart=on-failure and a 10-second RestartSec, which handles crash recovery automatically. Stop and start from the VPS terminal go through screen, so the server process survives SSH disconnections.

[Service]
Restart=on-failure
RestartSec=10
ExecStart=/usr/bin/screen -dmS boompala java -Xmx3G -Xms1G -jar fabric-server-launch.jar nogui
ExecStop=/usr/bin/screen -S boompala -X stuff "stop\n"

In a live classroom context, a server that crashes without automatic recovery means a minimum of ten minutes lost. This setup saved multiple sessions.

Missions and backend in Lua

All missions were coded in Lua via CC:Tweaked. The points system, the resource bank, the in-game shop: entirely implemented inside CC. No external mod for business logic, everything runs within the CC ecosystem.

One problem: CC’s built-in editor is unusable for real development. I worked around it with a vim pipeline: edit code outside CC, sync to the server, test. It works but it is a workaround. Finding a proper Lua editing workflow with a real LSP is one of the explicit items on the refactor list.

Sample structure for the points system:

-- bank.lua
local DISTRICT = "DISTRICT_NAME"
local EMERALD = "minecraft:emerald"
local SCAN_INTERVAL = 30

local modemSide = nil
for _, side in ipairs({"left","right","top","bottom","front","back"}) do
  local ptype = peripheral.getType(side)
  if ptype == "modem" or ptype == "wireless_modem" then
    modemSide = side
    break
  end
end
if modemSide then rednet.open(modemSide) end

local function compterEmeralds(chest)
  local total = 0
  local inv = peripheral.wrap(chest)
  if inv then
    for slot = 1, inv.size() do
      local item = inv.getItemDetail(slot)
      if item and item.name == EMERALD then
        total = total + item.count
      end
    end
  end
  return total
end

local function scannerTousLesChests()
  local total = 0
  local chests = {}

  -- turtle check the chest around it
  for _, side in ipairs({"left","right","front","back","top","bottom"}) do
    local ptype = peripheral.getType(side)
    if ptype == "minecraft:chest" or ptype == "chest" then
      table.insert(chests, side)
    end
  end

  for _, chest in ipairs(chests) do
    total = total + compterEmeralds(chest)
  end

  return total
end

local function envoyerScore(total)
  rednet.broadcast({
    cmd = "SCORE",
    district = DISTRICT,
    value = total
  }, "boompala")
end

-- Main Loop
while true do
  local total = scannerTousLesChests()
  envoyerScore(total)
  sleep(SCAN_INTERVAL)
end

When You Cannot Use the Server

Not all my classes have access to Minecraft. I also teach at a partner school where the machines are under strict contract and nothing can be installed.

Rather than abandoning the system, I transposed it. I rebuilt the same logic in Scratch: districts, tiered missions, collective points, live leaderboard. A Scratch Championship, currently in its last two sessions with those students.

The mechanics work independently of the technical stack. That is proof the pedagogical design holds without the original game, and that LastEra is not just a Minecraft server. It is a system.

What LastEra Will Be

The rebuild is called LastEra. The lore: a post-collapse world where two factions fight for control. Irony Corp, the megacorporation that owns the resources. ECHO, the resistance. Students pick a side.

Technical targets:

• Custom modpack on Modrinth
• FTB Quests for structured mission delivery
• LuckPerms for faction-based permission management
• CC:Tweaked for Lua scripting missions
• Companion website for out-of-game lore and progression

Approximately 20 missions per difficulty tier, two playable factions, visible progression system. The next devlogs will document the build week by week: modpack architecture, quest design, pedagogical integration, and the moments where it does not work as planned.

Next week: modpack selection and first architecture decisions.