OxideMiner: High-Performance Monero (XMR) CPU Miner in Rust

OxideMiner is a next-generation RandomX CPU miner written entirely in Rust. Engineered for speed, safety, and full transparency. It’s built to squeeze every cycle from your CPU while keeping your system secure and predictable. No hidden payloads, no opaque binaries...just verifiable, auditable performance.

📢 BETA TESTERS WANTED 🧪
Please visit oxide-randomx-public-beta to help provide crucial data related to the upcomming release of Oxide Miner's custom RandomX implementation. oxide-randomx will be the crate that adds a much needed performance boost to Oxide Miner. You can see the update I posted in the Discussions.

We ship a command-line miner with automatic CPU tuning, an optional embedded dashboard, and hardened controls for TLS, logging, and system friendliness. Every byte of it compiles from the code you see here.

Performance meets integrity. OxideMiner is what happens when modern Rust engineering meets Monero’s RandomX algorithm. Optimized for real-world rigs and safe for production hosts.

Note: This is an early-stage release. Expect rough edges while we stabilize and benchmark across more hardware. Bug reports and tuning data are especially valuable at this stage.

---

Table of contents

• Highlights
• Quick start
  • Super-Quick start
  • Build from source
  • Prerequisites
  • Build and install
  • First run
• Downloading and Verifying Releases
• Configuration
  • Huge / Large Pages
    • Windows
    • Linux
  • Command-line flags
  • Sample config.toml
  • Configuration warnings
• Operating the miner
  • Benchmark mode
  • Pool connectivity
  • Solo mining (monerod)
  • Huge pages & affinity
  • HTTP dashboard & API
  • Metrics reference
• Responsible usage
• Developer notes
  • Workspace layout
  • Building & testing
  • Contributing
• License
• Acknowledgments
• Contact

Highlights

TL;DR OxideMiner aims to be the most transparent, secure, and efficient RandomX CPU miner ever written in Rust.

• ⚡ Rust-first CPU miner: Built from the ground up in Rust for memory safety and predictable performance; with no C glue, no unsafe shortcuts. The oxide-core crate implements the RandomX hot loop, while oxide-miner orchestrates worker threads through Tokio for maximum throughput and minimal overhead.

• 🧠 Auto-tuned intelligence: At startup, OxideMiner introspects your CPU topology and cache sizes to pick the perfect thread count and batch size. You can always override them so you can squeeze every last drop of performance from you CPU.

• 🔒 TLS-ready stratum client: Secure pool connectivity via --tls, with optional certificate pinning and custom CA support.

• 📈 Prometheus-compatible metrics: The /metrics endpoint exposes rich counters and gauges, ready for Grafana dashboards or cluster monitoring.

• 🪶 Clean, structured logs: Human-readable by default, detailed under --debug. Rotating log files keep long runs tidy.

• 💎 Transparent dev fee: A fixed 1% developer fee, clearly logged and accounted for in metrics. No stealth mining, no surprises, just honesty.

• 📊 Built-in dashboard (with themes!): A modern, static web UI (HTML/CSS/JS fully embedded in the binary) shows hashrate, shares, uptime, connection state, build metadata, and a live ZMQ feed when solo ZMQ is enabled.

Now with extensible Themes like aurora and retro

Quick start

Super-Quick start

Download a pre-built binary from the Relases page, copy and rename 'config.toml.example' -> 'config.toml', fill in your desired pool & wallet address, run the miner:

Windows: .\oxide-miner.exe
Linux: ./oxide-miner

By default OxideMiner will look for a 'config.toml' file in the same directory as the binary, but you can supply the '--config <PATH_to_CONFIG.TOML>' argument.

CLI Screenshot

Build from source

Prerequisites

The steps below are for if you want to build from source.

• Rust toolchain via rustup (stable channel). The workspace targets Rust 2021 edition.
• A Monero-compatible mining pool endpoint and wallet address.
• For solo mining: a fully-synced local monerod with JSON-RPC enabled.
• Optional: elevated privileges for huge/large page support (see below).

Build and install

Clone the repository

git clone https://github.com/raystanza/OxideMiner.git
cd OxideMiner

Pick your compile method

OxideMiner supports multiple build configurations, depending on whether you want maximum compatibility or maximum performance on a specific machine.

cargo build --release
    [OR]
cargo build --profile maxperf
    [OR]
RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf

Explanation of each option:

• cargo build --release Builds OxideMiner using Cargo’s standard release profile. This produces a portable, optimized binary suitable for distribution and for running on a wide range of CPUs. Runtime CPU feature detection (AES, AVX2, etc.) is used to select the best available RandomX code paths at execution time.

• cargo build --profile maxperf Builds using OxideMiner’s custom maxperf profile, which enables more aggressive compiler optimizations (e.g. fat LTO, single codegen unit, stripped symbols). This improves performance while remaining portable across different CPUs. Recommended if you want better performance than --release without sacrificing compatibility.

• RUSTFLAGS="-C target-cpu=native" cargo build --profile maxperf Builds a host-optimized binary tuned specifically for the CPU on the machine performing the build. LLVM is allowed to fully specialize code generation for the host CPU (e.g. aes_ni, ssse3, avx2, avx512f, sse2). This typically yields the highest possible hash rate, but the resulting binary may not run on other machines.

Recommendation:

• Use --release for general use and distribution.
• Use --profile maxperf for improved performance with broad compatibility.
• Use --profile maxperf with target-cpu=native when building for a specific machine and absolute maximum performance is desired.

Install executable on your PATH (optional, Debian Linux)

install -Dm755 target/release/oxide-miner "$HOME/.local/bin/oxide-miner"

The CLI can also be run directly with cargo run -p oxide-miner --release -- <flags> while testing changes.

First run

Prefer the config.toml file for your first run. Copy config.toml.example to config.toml, fill in your pool and wallet, then run the miner.

# Preferred: config.toml in the same directory as the binary
./oxide-miner

By default OxideMiner looks for config.toml alongside the binary. Use --config <PATH> to point at a different file.

Command-line flags are also available if you prefer to launch without a config file:

# Example: plaintext stratum connection with HTTP dashboard on localhost (127.0.0.1:8080 by default)

oxide-miner \
  --url <Your.Pool.of.Choice:Port> \
  --user <YOUR_MONERO_WALLET> \
  --pass rig001 \
  --api-port 8080

Use --api-bind <ADDR> (for example --api-bind 0.0.0.0) if you need the dashboard reachable beyond 127.0.0.1.

For solo mining against a local monerod, use --mode solo (see the Solo mining section below).

Expected startup log flow:

1. CPU introspection and auto-tune summary (threads, batch size, cache, NUMA, huge page availability).
2. RandomX dataset initialization and worker spawn.
3. Stratum handshake with the configured pool, including dev-fee scheduler announcements.
4. HTTP API availability (if --api-port is set.)

Downloading and Verifying Releases

The project publishes signed release artifacts on the GitHub Releases page. Each release includes compressed binaries (.tar.gz for Linux, .zip for Windows), matching SHA-256 checksum files, and detached GPG signatures (.asc). Always verify downloads before running them to protect against tampering.

1. Download the official artifacts

1. Visit the Releases page and choose the tag you want (for example, v0.4.0).
2. Download the archive for your operating system and the accompanying checksum (.sha256). Download the .asc signature files as well.

2. Verify SHA-256 checksums

Validati