XMRig Mining

Mine Monero (XMR) and other cryptocurrencies using XMRig on Clore.ai's GPU and CPU servers.

XMRig is the most widely used open-source cryptocurrency miner. It supports CPU mining (RandomX algorithm for Monero) and GPU mining (KawPow, Ethash, and others). This guide covers deployment on Clore.ai servers.

Before you start: Always calculate profitability before mining. Factor in Clore.ai rental costs, pool fees, and current coin prices. Use a mining profitability calculator to ensure you're generating positive returns.

What Is XMRig?

XMRig is a high-performance, cross-platform miner for CPU and GPU:

Feature

Details

CPU mining

Monero (XMR) via RandomX — BEST use case

GPU mining

KawPow (RVN), Ethash variants, Octopus

Algorithms

RandomX, KawPow, Ethash, Autolykos2, Octopus + more

Stratum V2

Modern pool protocol support

TLS support

Encrypted pool connections

License

GPL 3.0, open source

Why Clore.ai for XMRig?

High-core-count CPUs: Clore.ai servers often have 32-128 CPU cores — ideal for RandomX
Spot pricing: Rent cheaply during off-peak hours
No hardware investment: Mine without buying and maintaining hardware
Flexibility: Switch algorithms or coins based on profitability

Profitability Check First

Do this before spending a single cent on rental costs!

Mining profitability changes daily. Always verify before starting.

Profitability Calculators

minerstat.com/calc — multi-algorithm
whattomine.com — comprehensive
xmrig.com/docs/algorithms — hashrate reference

Quick Math

Daily profit = (Daily reward in USD) - (Daily rental cost)

Example (Monero, 32-core server):
- Hashrate: ~32,000 H/s (1,000 H/s per core)
- Daily XMR reward: ~0.001-0.003 XMR/day
- XMR price (example): $160
- Daily revenue: $0.16-0.48
- Server rental (32-core, ~$0.20/hr): $4.80/day

Result: NEGATIVE. High-core servers often not profitable for solo mining.

Better approach: Find cheap high-core-count servers where rental < daily reward

When it makes sense: When you find a server with 64+ cores at $0.05-0.10/hr, or GPU servers at low spot prices for GPU-mineable coins. Always calculate first!

Prerequisites

Requirement

Details

Clore.ai account

With CLORE balance

Mining pool account

Create at supportXMR.com, MoneroOcean, etc.

Monero wallet

Download at getmonero.org (for XMR mining)

SSH access

Port 22

Create a Monero Wallet

# Option 1: CLI wallet
wget https://downloads.getmonero.org/cli/linux64
tar xzf monero-linux-x64-*.tar.bz2
./monero-x86_64-linux-gnu-v*/monero-wallet-cli --generate-new-wallet mywallet

# Option 2: GUI wallet (local machine)
# Download from: https://www.getmonero.org/downloads/

Save your wallet address — it looks like:

43xxxx...long string...xxxx

Step 1: Rent a Server

For CPU Mining (Monero/RandomX)

Go to clore.ai → Marketplace
Filter by CPU cores: 32+ cores preferred
Look for servers with high CPU thread count
Port 22 is sufficient
Order the server

For GPU Mining (KawPow, Octopus)

Filter by GPU: RTX 3080+, RTX 4090 for best performance
Ports needed: 22 only
NVIDIA GPUs only for CUDA mining

CPU vs GPU on Clore.ai: Clore.ai is primarily a GPU marketplace. For Monero (RandomX), dedicated CPU servers may be cheaper. For GPU-mineable coins, NVIDIA servers offer better performance.

Step 2: Deploy XMRig via Docker

Custom Dockerfile

Create a Dockerfile on the server:

FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# Install dependencies
RUN apt-get update && apt-get install -y \
    wget \
    libssl-dev \
    libhwloc-dev \
    libuv1-dev \
    build-essential \
    cmake \
    git \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/xmrig

# Download XMRig release
RUN wget https://github.com/xmrig/xmrig/releases/download/v6.21.3/xmrig-6.21.3-linux-static-x64.tar.gz \
    && tar xzf xmrig-*.tar.gz \
    && mv xmrig-*/xmrig . \
    && rm -rf xmrig-*.tar.gz xmrig-*/

# Create config directory
RUN mkdir -p /etc/xmrig

ENTRYPOINT ["/opt/xmrig/xmrig"]

Build Image

docker build -t xmrig-miner .

Run CPU Mining (Monero)

docker run -d \
  --name xmrig-cpu \
  --restart unless-stopped \
  --privileged \
  xmrig-miner \
  -o pool.supportxmr.com:443 \
  -u YOUR_MONERO_WALLET_ADDRESS \
  -p worker1 \
  -k \
  --tls \
  --cpu-max-threads-hint=100 \
  --log-file=/var/log/xmrig.log

Run GPU Mining (KawPow - Ravencoin)

docker run -d \
  --name xmrig-gpu \
  --restart unless-stopped \
  --gpus all \
  xmrig-miner \
  -a kawpow \
  -o rvn.2miners.com:6060 \
  -u YOUR_RVN_WALLET.worker1 \
  --log-file=/var/log/xmrig.log

Step 3: Configuration File Method

Using a config file is cleaner than command-line flags.

Create `config.json`

{
    "autosave": true,
    "background": false,
    "colors": true,
    "title": true,
    "api": {
        "id": null,
        "worker-id": "clore-worker-1",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "http": {
        "enabled": true,
        "host": "0.0.0.0",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "randomx": {
        "init": -1,
        "init-avx2": -1,
        "mode": "auto",
        "1gb-pages": false,
        "rdmsr": true,
        "wrmsr": true,
        "cache_qos": false,
        "numa": true,
        "scratchpad_prefetch_mode": 1
    },
    "cpu": {
        "enabled": true,
        "huge-pages": true,
        "huge-pages-jit": false,
        "hw-aes": null,
        "priority": null,
        "memory-pool": false,
        "yield": true,
        "max-threads-hint": 100,
        "asm": true,
        "argon2-impl": null,
        "astrobwt-max-size": 550,
        "astrobwt-avx2": false
    },
    "opencl": {
        "enabled": false,
        "cache": true,
        "loader": null,
        "platform": "AMD"
    },
    "cuda": {
        "enabled": true,
        "loader": null,
        "nvml": true
    },
    "log-file": null,
    "donate-level": 1,
    "donate-over-proxy": 1,
    "pools": [
        {
            "algo": null,
            "coin": "XMR",
            "url": "pool.supportxmr.com:443",
            "user": "YOUR_MONERO_WALLET_ADDRESS",
            "pass": "worker1",
            "rig-id": null,
            "nicehash": false,
            "keepalive": true,
            "enabled": true,
            "tls": true,
            "tls-fingerprint": null,
            "daemon": false,
            "socks5": null,
            "self-select": null,
            "submit-to-origin": false
        }
    ],
    "print-time": 60,
    "health-print-time": 60,
    "dmi": true,
    "retries": 5,
    "retry-pause": 5,
    "syslog": false,
    "tls": {
        "enabled": false,
        "protocols": null,
        "cert": null,
        "cert_key": null,
        "ciphers": null,
        "ciphersuites": null,
        "dhparam": null
    },
    "dns": {
        "ipv6": false,
        "ttl": 30
    },
    "user-agent": null,
    "verbose": 0,
    "watch": true
}

Replace YOUR_MONERO_WALLET_ADDRESS with your actual wallet address.

Run with Config File

docker run -d \
  --name xmrig \
  --restart unless-stopped \
  --privileged \
  -v $(pwd)/config.json:/etc/xmrig/config.json \
  xmrig-miner \
  --config=/etc/xmrig/config.json

Step 4: Enable Huge Pages (Performance Boost)

RandomX benefits significantly from 1GB huge pages. Enable on the host:

# Enable huge pages (run on Clore.ai server as root)
echo 1 > /proc/sys/vm/nr_hugepages

# For 1GB huge pages (if supported by CPU)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

# Make persistent
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p

Performance impact: Huge pages can increase Monero hashrate by 20-50% on some CPUs. Worth enabling if you have access to the host system.

Step 5: Monitor Mining

Check Container Status

# View real-time logs
docker logs xmrig -f

# Check stats via API
curl http://localhost:9090/2/summary | python3 -m json.tool

Sample Log Output

[2024-03-01 10:15:23.456]  miner    speed 10s/60s/15m 31.2k 31.4k 31.1k H/s max 32.1k H/s
[2024-03-01 10:15:30.123]  net      accepted (1/0) diff 200001 (123 ms)
[2024-03-01 10:16:00.789]  miner    speed 10s/60s/15m 31.5k 31.3k 31.2k H/s max 32.1k H/s

Key Metrics to Watch

Metric

What It Means

H/s (hashrate)

Mining speed — higher is better

Accepted shares

Valid work submitted to pool

Rejected shares

Invalid work — should be near 0

Latency

Pool connection speed

Pool Dashboard

Check your progress at your pool's website:

SupportXMR: https://supportxmr.com/#/dashboard?wallet=YOUR_ADDRESS
MoneroOcean: https://moneroocean.stream/#/dashboard?wallet=YOUR_ADDRESS
2Miners: https://xmr.2miners.com/account/YOUR_ADDRESS

Popular Mining Pools

Monero (XMR) Pools

Pool

URL

Fee

Min Payout

SupportXMR

pool.supportxmr.com:443

0.6%

0.1 XMR

MoneroOcean

gulf.moneroocean.stream:443

0.003 XMR

XMRig Pool

pool.xmrig.com:443

0.01 XMR

MineXMR

pool.minexmr.com:4444

0.004 XMR

GPU-Mineable Coins

Coin

Algorithm

Pool Example

Ravencoin (RVN)

KawPow

rvn.2miners.com:6060

Ergo (ERG)

Autolykos2

erg.2miners.com:8888

Conflux (CFX)

Octopus

cfx.2miners.com:4040

Ethereum Classic (ETC)

Etchash

etc.2miners.com:1010

MoneroOcean is special: It automatically switches your miner to the most profitable algorithm at any given time, while still paying in XMR. Great for maximizing returns.

MoneroOcean: Auto-Profit Switching

MoneroOcean automatically mines the most profitable algorithm:

docker run -d \
  --name xmrig-mo \
  --restart unless-stopped \
  --privileged \
  xmrig-miner \
  --algo=rx/0 \
  -o gulf.moneroocean.stream:443 \
  -u YOUR_MONERO_WALLET \
  -p "YOUR_WORKER:PERFORMANCE_FEE" \
  --tls \
  --cpu-max-threads-hint=95

Optimization Tips

CPU Optimization

# Use all CPU threads
--cpu-max-threads-hint=100

# Set CPU priority (0=lowest, 5=highest)
--cpu-priority=3

# Disable yield (don't share CPU with other processes)
--no-yield

# Enable AVX2 for faster RandomX
# (automatic if CPU supports it)

GPU Optimization (CUDA)

"cuda": {
    "enabled": true,
    "loader": null,
    "nvml": true,
    "devices": [
        {
            "index": 0,
            "threads": 512,
            "blocks": 0,
            "bfactor": 0,
            "bsleep": 0,
            "affinity": -1
        }
    ]
}

Dual Mining (CPU + GPU)

"cpu": {
    "enabled": true,
    "max-threads-hint": 100
},
"cuda": {
    "enabled": true,
    "nvml": true
}

Security Considerations

Mining security checklist:

Never run miners as root if possible
Don't expose the XMRig API port (9090) publicly
Use TLS connections to pools (--tls flag)
Keep XMRig updated to patch vulnerabilities
Monitor for unusual CPU/GPU usage spikes

Protect API Endpoint

"api": {
    "port": 9090,
    "access-token": "your-secret-token-here",
    "restricted": true
}

# Access with token
curl -H "Authorization: Bearer your-secret-token-here" \
     http://localhost:9090/2/summary

Automated Profit Monitoring Script

#!/bin/bash
# monitor-mining.sh

WALLET="YOUR_WALLET_ADDRESS"
RENTAL_COST_PER_HOUR=0.50  # Your Clore.ai cost in USD

while true; do
  # Get current hashrate
  HASHRATE=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['hashrate']['total'][0])")
  
  echo "$(date): Hashrate: ${HASHRATE} H/s"
  echo "$(date): Hourly cost: \$${RENTAL_COST_PER_HOUR}"
  
  # Check accepted shares
  ACCEPTED=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['results']['shares_good'])")
  echo "$(date): Accepted shares: ${ACCEPTED}"
  
  sleep 300  # Check every 5 minutes
done

Troubleshooting

Low Hashrate

# Check CPU allocation in container
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# Ensure huge pages are enabled
cat /proc/sys/vm/nr_hugepages

# Check for thermal throttling
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"

Connection Issues

# Test pool connectivity
curl -k telnet://pool.supportxmr.com:443

# Use alternative pool if blocked
# Try: xmr.pool.minergate.com:443

CUDA Errors

# Verify GPU access in container
docker exec xmrig-gpu nvidia-smi

# If missing, add --gpus all to docker run
docker stop xmrig-gpu
docker rm xmrig-gpu
# Re-run with --gpus all

Container Keeps Restarting

# Check exit code
docker inspect xmrig --format='{{.State.ExitCode}}'

# View detailed logs
docker logs xmrig --since 5m

# Common causes:
# - Invalid wallet address
# - Pool connection failed
# - Config file syntax error

Legal and Ethical Notes

Important considerations:

Check Clore.ai ToS: Ensure mining is permitted on your rented servers
Tax compliance: Mined cryptocurrency may be taxable income in your jurisdiction
Profitability: Cloud mining is often unprofitable — do your math first
Network effect: Mining contributes to blockchain security (positive contribution)

Quick Reference

Command-Line Flags

Flag

Description

-o URL

Pool address

-u ADDRESS

Wallet address

-p WORKER

Worker name

-a ALGO

Algorithm (rx/0 for Monero)

--tls

Enable TLS encryption

-k

Keepalive connection

--cpu-max-threads-hint=N

Use N% of CPU threads

--donate-level=0

Disable dev donation

Algorithm Reference

Algorithm

Coin

Best Hardware

rx/0

Monero (XMR)

CPU (RandomX)

kawpow

Ravencoin (RVN)

GPU

autolykos2

Ergo (ERG)

GPU

octopus

Conflux (CFX)

GPU

etchash

ETC

GPU

Useful Links

Summary

Step

Action

Calculate profitability FIRST

Create Monero wallet at getmonero.org

Rent server (CPU cores for XMR, GPU for others)

Build XMRig Docker image

Configure config.json with wallet and pool

Enable huge pages for 20-50% hashrate boost

Start mining and monitor via pool dashboard

XMRig on Clore.ai gives you access to high-performance mining hardware on demand. Use it strategically — mine when prices are high and rental costs are low. Always do the math first. ⛏️

Clore.ai GPU Recommendations

Use Case

Recommended GPU

Est. Cost on Clore.ai

Entry-level Mining

RTX 3080 (10GB)

~$0.08/gpu/hr

Optimal Mining

RTX 3090 (24GB)

~$0.12/gpu/hr

High-performance Mining

RTX 4090 (24GB)

~$0.70/gpu/hr

💡 All examples in this guide can be deployed on Clore.ai GPU servers. Browse available GPUs and rent by the hour — no commitments, full root access.

PreviousOverview NextOverview

Last updated 1 day ago

Was this helpful?

hashtagWhat Is XMRig?

hashtagWhy Clore.ai for XMRig?

hashtagProfitability Check First

hashtagProfitability Calculators

hashtagQuick Math

hashtagPrerequisites

hashtagCreate a Monero Wallet

hashtagStep 1: Rent a Server

hashtagFor CPU Mining (Monero/RandomX)

hashtagFor GPU Mining (KawPow, Octopus)

hashtagStep 2: Deploy XMRig via Docker

hashtagCustom Dockerfile

hashtagBuild Image

hashtagRun CPU Mining (Monero)

hashtagRun GPU Mining (KawPow - Ravencoin)

hashtagStep 3: Configuration File Method

hashtagCreate config.json

hashtagRun with Config File

hashtagStep 4: Enable Huge Pages (Performance Boost)

hashtagStep 5: Monitor Mining

hashtagCheck Container Status

hashtagSample Log Output

hashtagKey Metrics to Watch

hashtagPool Dashboard

hashtagPopular Mining Pools

hashtagMonero (XMR) Pools

hashtagGPU-Mineable Coins

hashtagMoneroOcean: Auto-Profit Switching

hashtagOptimization Tips

hashtagCPU Optimization

hashtagGPU Optimization (CUDA)

hashtagDual Mining (CPU + GPU)

hashtagSecurity Considerations

hashtagProtect API Endpoint

hashtagAutomated Profit Monitoring Script

hashtagTroubleshooting

hashtagLow Hashrate

hashtagConnection Issues

hashtagCUDA Errors

hashtagContainer Keeps Restarting

hashtagLegal and Ethical Notes

hashtagQuick Reference

hashtagCommand-Line Flags

hashtagAlgorithm Reference

hashtagUseful Links

hashtagSummary

hashtagClore.ai GPU Recommendations

What Is XMRig?

Why Clore.ai for XMRig?

Profitability Check First

Profitability Calculators

Quick Math

Prerequisites

Create a Monero Wallet

Step 1: Rent a Server

For CPU Mining (Monero/RandomX)

For GPU Mining (KawPow, Octopus)

Step 2: Deploy XMRig via Docker

Custom Dockerfile

Build Image

Run CPU Mining (Monero)

Run GPU Mining (KawPow - Ravencoin)

Step 3: Configuration File Method

Create `config.json`

Run with Config File

Step 4: Enable Huge Pages (Performance Boost)

Step 5: Monitor Mining

Check Container Status

Sample Log Output

Key Metrics to Watch

Pool Dashboard

Popular Mining Pools

Monero (XMR) Pools

GPU-Mineable Coins

MoneroOcean: Auto-Profit Switching

Optimization Tips

CPU Optimization

GPU Optimization (CUDA)

Dual Mining (CPU + GPU)

Security Considerations

Protect API Endpoint

Automated Profit Monitoring Script

Troubleshooting

Low Hashrate

Connection Issues

CUDA Errors

Container Keeps Restarting

Legal and Ethical Notes

Quick Reference

Command-Line Flags

Algorithm Reference

Useful Links

Summary

Clore.ai GPU Recommendations