# XMRig Mining

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

{% hint style="info" %}
**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.
{% endhint %}

{% hint style="warning" %}
**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.
{% endhint %}

***

## 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

{% hint style="danger" %}
**Do this before spending a single cent on rental costs!**

Mining profitability changes daily. Always verify before starting.
{% endhint %}

### Profitability Calculators

* [minerstat.com/calc](https://minerstat.com/calc) — multi-algorithm
* [whattomine.com](https://whattomine.com) — comprehensive
* [xmrig.com/docs/algorithms](https://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
```

{% hint style="success" %}
**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!
{% endhint %}

***

## 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

```bash
# 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)

1. Go to [clore.ai](https://clore.ai) → **Marketplace**
2. Filter by **CPU cores**: 32+ cores preferred
3. Look for servers with high CPU thread count
4. Port **22** is sufficient
5. Order the server

### For GPU Mining (KawPow, Octopus)

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

{% hint style="info" %}
**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.
{% endhint %}

***

## Step 2: Deploy XMRig via Docker

### Custom Dockerfile

Create a `Dockerfile` on the server:

```dockerfile
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

```bash
docker build -t xmrig-miner .
```

### Run CPU Mining (Monero)

```bash
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)

```bash
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`

```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

```bash
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:

```bash
# 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
```

{% hint style="info" %}
**Performance impact**: Huge pages can increase Monero hashrate by 20-50% on some CPUs. Worth enabling if you have access to the host system.
{% endhint %}

***

## Step 5: Monitor Mining

### Check Container Status

```bash
# 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%   | 0.003 XMR  |
| XMRig Pool  | pool.xmrig.com:443          | 1%   | 0.01 XMR   |
| MineXMR     | pool.minexmr.com:4444       | 1%   | 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 |

{% hint style="info" %}
**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.
{% endhint %}

***

## MoneroOcean: Auto-Profit Switching

MoneroOcean automatically mines the most profitable algorithm:

```bash
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

```bash
# 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)

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

### Dual Mining (CPU + GPU)

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

***

## Security Considerations

{% hint style="warning" %}
**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
  {% endhint %}

### Protect API Endpoint

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

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

***

## Automated Profit Monitoring Script

```bash
#!/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

```bash
# 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

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

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

### CUDA Errors

```bash
# 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

```bash
# 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

{% hint style="info" %}
**Important considerations:**

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

***

## 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

* [XMRig GitHub](https://github.com/xmrig/xmrig)
* [XMRig Documentation](https://xmrig.com/docs)
* [WhatToMine Calculator](https://whattomine.com)
* [MoneroOcean Pool](https://moneroocean.stream)
* [SupportXMR Pool](https://supportxmr.com)
* [Clore.ai Marketplace](https://clore.ai)

***

## Summary

| Step | Action                                          |
| ---- | ----------------------------------------------- |
| 1    | Calculate profitability FIRST                   |
| 2    | Create Monero wallet at getmonero.org           |
| 3    | Register at a mining pool                       |
| 4    | Rent server (CPU cores for XMR, GPU for others) |
| 5    | Build XMRig Docker image                        |
| 6    | Configure config.json with wallet and pool      |
| 7    | Enable huge pages for 20-50% hashrate boost     |
| 8    | 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](https://clore.ai/marketplace) GPU servers. Browse available GPUs and rent by the hour — no commitments, full root access.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/crypto-and-mining/xmrig.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.