Building a Hardcore Minecraft Server with Shared Health and Damage Tracking

Want to create an intense, collaborative Minecraft experience? This guide walks through setting up a hardcore server where players share health and every point of damage matters. Perfect for speedrun challenges or just adding stakes to your survival gameplay.

What We’re Building

A Minecraft Fabric server with:

Shared health pool across all players
Comprehensive damage logging with detailed tracking
Milestone tracking (Iron, Nether, Fortress, End, Dragon)
Run persistence - save and compare attempts
Spectator mode on death for dramatic endings
Damage leaderboards to see who took the most hits

This setup is inspired by hardcore speedrun servers but works great for any group that wants high-stakes collaborative survival.

Prerequisites

What You’ll Need:

Ubuntu Server 22.04+ (or any Linux distribution)
Java 21 (for Minecraft 1.21.10+)
4GB+ RAM (recommended)
Basic terminal knowledge

My Setup:

I’m running this on a Proxmox LXC container with:

4GB RAM allocated
Ubuntu 22.04 template
Network bridge for external access

Part 1: Server Installation

Install Java 21

# Update system
sudo apt update && sudo apt upgrade -y

# Install Java 21
sudo apt install openjdk-21-jdk -y

# Verify installation
java -version

You should see something like openjdk version "21.0.x".

Download Fabric Server

# Create server directory
mkdir -p /opt/minecraft/server
cd /opt/minecraft/server

# Download Fabric installer (check https://fabricmc.net/use/server/ for latest version)
wget https://maven.fabricmc.net/net/fabricmc/fabric-installer/1.0.1/fabric-installer-1.0.1.jar

# Install Fabric server for Minecraft 1.21.10
java -jar fabric-installer-1.0.1.jar server -mcversion 1.21.10 -downloadMinecraft

Initial Server Configuration

# Accept EULA
echo "eula=true" > eula.txt

# Create server.properties with basic settings
cat > server.properties << 'EOF'
server-port=25565
gamemode=survival
difficulty=hard
hardcore=true
max-players=10
view-distance=12
simulation-distance=8
motd=Hardcore Shared Health Server
enable-command-block=false
spawn-protection=0
max-world-size=29999984
EOF

First Boot Test

# Start server to generate world
java -Xmx3G -Xms3G -jar fabric-server-launch.jar nogui

Wait for “Done!” then type stop to shut it down gracefully.

Part 2: Installing Mods

Download Required Mods

# Create mods directory
mkdir -p /opt/minecraft/server/mods
cd /opt/minecraft/server/mods

# Download Fabric API (required dependency)
# Check https://modrinth.com/mod/fabric-api for the latest 1.21.10 compatible version
wget https://cdn.modrinth.com/data/P7dR8mSH/versions/[FABRIC_API_VERSION]/fabric-api-[VERSION].jar

# Download Shared Health mod
# From https://modrinth.com/mod/sharedhealth
wget https://cdn.modrinth.com/data/xzHWwh0L/versions/[SHAREDHEALTH_VERSION]/sharedhealth-[VERSION].jar

# Download DamageLogger mod
# From https://github.com/DerkieH/DamageLoggerMod/releases
wget https://github.com/DerkieH/DamageLoggerMod/releases/download/1.3.9/damagelogger-1.3.9.jar

Version Notes:

DamageLogger 1.3.9 is confirmed compatible with Minecraft 1.21.10
Shared Health supports 1.21.10-1.21.11
Always grab the latest Fabric API for your Minecraft version

Verify Mod Installation

# List mods
ls -lh /opt/minecraft/server/mods

# You should see:
# - fabric-api-*.jar
# - sharedhealth-*.jar  
# - damagelogger-1.3.9.jar

Create Data Directory for DamageLogger

# DamageLogger saves run data here
mkdir -p /opt/minecraft/server/splits
chmod 755 /opt/minecraft/server/splits

Part 3: Mod Configuration

Shared Health Configuration

Shared Health uses Minecraft’s native gamerule system. Configure after starting the server:

# Start server
java -Xmx3G -Xms3G -jar fabric-server-launch.jar nogui

In the server console:

# Enable shared health (default: true)
/gamerule shareHealth true

# Enable shared hunger (default: true)
/gamerule shareHunger true

How it works:

All players share a single health pool
All players share a single hunger bar
Damage to one player affects everyone
Eating food benefits everyone

DamageLogger Configuration

DamageLogger works out of the box with no configuration needed. It automatically:

Logs all damage events to chat with color coding
Tracks milestones via advancements
Maintains a damage leaderboard per run
Saves completed/failed runs to JSON
Displays split times on sidebar scoreboard

Key Features:

Damage Logging:

Color-coded messages: [Damage] player took X damage
Anti-spam cooldowns (longer for DoT sources)
Ignores /kill commands

Milestone Tracking:

IRON: First iron smelted
NETHER: Enter the Nether
FORT: Find Nether Fortress
BLAZE: Obtain Blaze Rod
END: Enter the End
DRAGON: Kill Ender Dragon

Run End Conditions:

FAILED: First real player death → everyone to spectator mode
COMPLETED: Ender Dragon killed

Part 4: Systemd Service Setup

Create a systemd service for automatic startup and management:

sudo nano /etc/systemd/system/minecraft.service

Paste this configuration:

[Unit]
Description=Minecraft Hardcore Server
After=network.target

[Service]
Type=simple
User=minecraft
WorkingDirectory=/opt/minecraft/server
ExecStart=/usr/bin/java -Xmx3G -Xms3G -jar fabric-server-launch.jar nogui
Restart=on-failure
RestartSec=10

# Graceful shutdown
ExecStop=/bin/sh -c 'echo "stop" > /run/minecraft.stdin'
StandardInput=file:/run/minecraft.stdin
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Create minecraft user:

# Create dedicated user
sudo useradd -r -m -U -d /opt/minecraft -s /bin/bash minecraft

# Set ownership
sudo chown -R minecraft:minecraft /opt/minecraft

# Enable and start service
sudo systemctl daemon-reload
sudo systemctl enable minecraft
sudo systemctl start minecraft

Manage the server:

# Check status
sudo systemctl status minecraft

# View logs
sudo journalctl -u minecraft -f

# Stop server
sudo systemctl stop minecraft

# Restart server
sudo systemctl restart minecraft

Part 5: Understanding the Gameplay

How Shared Health Works

When you have 3 players online:

Total health pool: 60 HP (20 HP × 3 players)
Player A takes 5 damage: Everyone loses ~1.67 HP
Player B eats: Everyone gains health
One player dies: Run fails, everyone becomes spectator

This creates intense cooperation - careless players affect everyone.

The Run Flow

Start:

Server boots
New run begins automatically
Sidebar shows milestone targets based on best previous run

During Run:

Damage logged in chat with color coding
Damage leaderboard tracks who’s taking hits
Milestones announced when reached
Split times show delta vs best run

Run Failure (First Death):

Death detected
All players forced to respawn (bypasses Game Over screen)
All players switched to Spectator mode
Everyone teleported to death location
5-second “pin” at death spot
Dramatic broadcast: “RUN FAILED - HH:MM:SS”
Top 5 damage leaderboard displayed
Run saved to /opt/minecraft/server/splits/runs.json

Run Completion (Dragon Kill):

Ender Dragon dies
Broadcast: “RUN COMPLETED - HH:MM:SS”
Damage leaderboard shown
Run saved to JSON
No spectator mode (it’s a victory!)

Scoreboard Display

The sidebar shows:

ALLIANCE SPLITS
━━━━━━━━━━━━━━
⚪ IRON
⚪ NETHER  
⚪ FORT
⚪ BLAZE
⚪ END
⚪ DRAGON

As milestones are hit:

ALLIANCE SPLITS
━━━━━━━━━━━━━━
✓ IRON (+00:00:12)
✓ NETHER (-00:00:05)
⚪ FORT
⚪ BLAZE
⚪ END
⚪ DRAGON

Green ✓ = completed + = slower than best - = faster than best (NEW PB!)

Part 6: Backups and Run Data

Backup Strategy

#!/bin/bash
# /opt/minecraft/backup.sh

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/opt/minecraft/backups"
SERVER_DIR="/opt/minecraft/server"

# Create backup directory
mkdir -p $BACKUP_DIR

# Stop server
sudo systemctl stop minecraft

# Backup world and run data
tar -czf $BACKUP_DIR/server_$DATE.tar.gz \
    -C $SERVER_DIR \
    world world_nether world_the_end splits

# Start server
sudo systemctl start minecraft

# Keep only last 7 backups
cd $BACKUP_DIR
ls -t | tail -n +8 | xargs -r rm

Make it executable and schedule:

chmod +x /opt/minecraft/backup.sh

# Add to crontab (daily at 4 AM)
sudo crontab -e
0 4 * * * /opt/minecraft/backup.sh

Analyzing Run Data

Run data is saved to /opt/minecraft/server/splits/runs.json:

{
  "runs": [
    {
      "id": "run_20250121_143052",
      "outcome": "FAILED",
      "duration": "01:23:45",
      "splits": {
        "IRON": "00:02:15",
        "NETHER": "00:15:30",
        "FORT": "00:25:00"
      },
      "damageLeaderboard": [
        {"player": "Steve", "damage": 45.5},
        {"player": "Alex", "damage": 32.0}
      ]
    }
  ]
}

You can parse this with jq:

# Show all completed runs
jq '.runs[] | select(.outcome == "COMPLETED")' splits/runs.json

# Show best NETHER split time
jq -r '.runs[].splits.NETHER' splits/runs.json | sort | head -1

# Show total runs
jq '.runs | length' splits/runs.json

Part 7: Troubleshooting

Server Won’t Start

Check Java version:

java -version
# Should show Java 21

Check logs:

sudo journalctl -u minecraft -n 100 --no-pager

Common issues:

Port 25565 already in use: sudo lsof -i :25565
Insufficient memory: Increase -Xmx value
Missing Fabric API: Required for both mods

Mods Not Loading

Verify mod files:

ls -lh /opt/minecraft/server/mods

Check each .jar file:

Fabric API: Must match Minecraft version exactly
Shared Health: Should show 1.21.10 compatibility
DamageLogger: Version 1.3.9 for 1.21.10

Check server logs:

tail -f /opt/minecraft/server/logs/latest.log

Look for:

[Fabric] Loading mods...
[Fabric] - sharedhealth 
[Fabric] - damagelogger

Shared Health Not Working

Verify gamerules:

# In server console
/gamerule shareHealth
/gamerule shareHunger

Both should return true.

Test it:

Have two players join
One player takes damage
Both players should lose health proportionally

Splits Not Saving

Check directory permissions:

ls -ld /opt/minecraft/server/splits
# Should be owned by minecraft user with write access

sudo chown -R minecraft:minecraft /opt/minecraft/server/splits
sudo chmod -R 755 /opt/minecraft/server/splits

Check disk space:

df -h /opt/minecraft

Performance Issues

Optimize Java flags:

# For 4GB RAM server
java -Xmx3G -Xms3G \
  -XX:+UseG1GC \
  -XX:+ParallelRefProcEnabled \
  -XX:MaxGCPauseMillis=200 \
  -XX:+UnlockExperimentalVMOptions \
  -XX:+DisableExplicitGC \
  -XX:G1NewSizePercent=30 \
  -XX:G1MaxNewSizePercent=40 \
  -XX:G1HeapRegionSize=8M \
  -jar fabric-server-launch.jar nogui

Monitor performance:

# CPU and memory
htop

# Server TPS
# In-game: /forge tps

Part 8: Advanced Customization

World Reset Script

For speedrun practice, you might want quick world resets:

#!/bin/bash
# /opt/minecraft/reset-world.sh

echo "Stopping server..."
sudo systemctl stop minecraft

echo "Backing up old world..."
cd /opt/minecraft/server
tar -czf "world_backup_$(date +%Y%m%d_%H%M%S).tar.gz" world world_nether world_the_end

echo "Removing world files..."
rm -rf world world_nether world_the_end

echo "Starting server (new world will generate)..."
sudo systemctl start minecraft

echo "World reset complete!"

Custom MOTD

Update your server.properties:

motd=§c§lHARDCORE§r§7 | Shared Health Challenge\n§e1.21.10§7 | speedrun.homehosted.org

Colors:

§c = red
§e = yellow
§7 = gray
§l = bold
§r = reset

Whitelist for Practice Sessions

# Enable whitelist
echo "white-list=true" >> server.properties

# Add players (in server console)
/whitelist add PlayerName
/whitelist add AnotherPlayer

# Or via command line
echo "whitelist add PlayerName" | sudo -u minecraft java -jar fabric-server-launch.jar

Conclusion

You now have a fully functional hardcore Minecraft server with:

✅ Shared health mechanics across all players
✅ Comprehensive damage tracking and leaderboards
✅ Milestone/split tracking for speedruns
✅ Automatic run persistence to JSON
✅ Dramatic death sequences
✅ Systemd service for easy management

This setup creates incredible tension and cooperation. Every decision matters when one player’s mistake can end the run for everyone.

What’s Next?

Some ideas to enhance your server:

Add more mods: Consider VoiceChat mod for better coordination
Stream integration: Parse run data for overlays
Leaderboard website: Display historical runs and stats
Custom challenges: Set speedrun goals (beat Dragon in under 30 minutes)
Tournament mode: Track multiple teams competing

Resources

Have you set up a similar server? Found better configurations? I’d love to hear about it - reach out via GitHub!

What We’re Building#

Prerequisites#

Part 1: Server Installation#

Install Java 21#

Download Fabric Server#

Initial Server Configuration#

First Boot Test#

Part 2: Installing Mods#

Download Required Mods#

Verify Mod Installation#

Create Data Directory for DamageLogger#

Part 3: Mod Configuration#

Shared Health Configuration#

DamageLogger Configuration#

Part 4: Systemd Service Setup#

Part 5: Understanding the Gameplay#

How Shared Health Works#

The Run Flow#

Scoreboard Display#

Part 6: Backups and Run Data#

Backup Strategy#

Analyzing Run Data#

Part 7: Troubleshooting#

Server Won’t Start#

Mods Not Loading#

Shared Health Not Working#

Splits Not Saving#

Performance Issues#

Part 8: Advanced Customization#

World Reset Script#

Custom MOTD#

Whitelist for Practice Sessions#

Conclusion#

What’s Next?#

Resources#