Turning Old Cell Phones Into CPU Miners

There is something satisfying about putting old hardware back to work.

A lot of people have old Android phones laying around with cracked screens, weak batteries, or no real purpose anymore. They may not be powerhouses, but they can still be turned into little worker units. In my case, I wanted a way to get CPU miners running on old cell phones and then manage them from a Windows machine without having to baby each phone one by one.

That is where this setup comes in.

I put together a GitHub repo here:

https://github.com/PaulMoon410/win_mine

That repository is a PowerShell-based starter kit for running miners from Windows through PuTTY plink over SSH. The repo includes a shared config file, a miner template, start/check/kill scripts, and multi-device monitoring scripts. The README specifically lists miner\_common.ps1, bot\_TEMPLATE.ps1, cell\_start.ps1, cell\_check.ps1, cell\_kill.ps1, monitor\_all.ps1, and start\_all.ps1 as the core files in the workflow.

Why I like this setup

Instead of tapping around on each phone every time I want to start or monitor a miner, I can use one Windows machine as the command center.

My repo is built around that idea:

one shared config file for miner settings
one template script for a single miner
one script to start them all
one script to check them all
one script to kill them all
one script to monitor output across multiple devices

The repo README calls it a reusable starter kit for running miners from Windows via PowerShell + PuTTY plink, and the included notes say the scripts use SSH on port 8022.

What you need

Before using the Windows launcher side, you need a few basics in place on the phones.

For Android, Termux is one of the easiest ways to create a Linux-like command-line environment on the device. You will generally want:

Termux installed
package lists updated
OpenSSH installed
Git installed
compiler/build tools if you are compiling the miner on-device
your miner binary placed in the expected folder
SSH running on the phone so Windows can connect to it

On each Android phone, inside Termux, a typical setup looks like this:

pkg update \&\& pkg upgrade -y
pkg install openssh git clang make -y
passwd
sshd

That gets the phone closer to being reachable over SSH and gives you the basic tools needed to pull code and build software in Termux. The exact miner build can vary depending on whether you are using cpuminer-opt, cpuminer-multi, or another CPU miner source tree.

Put the miner where the Windows scripts expect it

My repo already assumes certain working directories for the phones configured in miner\_common.ps1.

Right now, the sample config in the repo shows three miner entries:

device 157 using u0\_a312@192.168.1.157 with working directory \~/cpuminer-multi
device 188 using u0\_a171@192.168.1.188 with working directory \~/cpuminer-opt
device 189 using u0\_a451@192.168.1.189 with working directory \~/cpuminer-opt

So the practical part is simple:

clone or place your miner source in the folder you want
compile it if needed
make sure the executable exists where the script expects it

In miner\_common.ps1, the default executable is set as:

$Script:MinerExecutable = "./cpuminer"

The same file also sets the sample pool, wallet placeholder, and password argument placeholder.

What to edit in the GitHub repo

The first file to edit is:

miner\_common.ps1

That same script currently contains examples like:

PlinkPath = "C:\\Program Files\\PuTTY\\plink.exe"
MinerPassword = "CHANGE\_ME"
MinerWallet = "CHANGE\_ME\_WALLET"
a sample pool of stratum+tcp://yescrypt.na.mine.zpool.ca:6233
device definitions for 157, 188, and 189

So after downloading the repo, the first job is replacing all the placeholder values with your actual setup.

Old cell phones are not going to compete with real mining hardware. They are small CPU workers. They are more useful for experimentation, learning, testing pools, running low-power background mining, or making use of hardware that would otherwise just collect dust.

The bigger value here, at least to me, is the system itself: