DEV Community: BeaconKVM

BeaconKVM or PiKVM: build your own IP KVM with a Raspberry Pi

BeaconKVM — Mon, 28 Sep 2026 08:49:37 +0000

We recently built an IP KVM of our own — BeaconKVM. The best-known product in
this space is PiKVM, so in this article we're going to compare ourselves with
PiKVM and see where we do well, where we're only average, and where we could
improve.

Both BeaconKVM and PiKVM have a Raspberry Pi version, which means you can get
either of them running without buying any hardware. That's a fairly obvious
difference from most other KVMs.

This article is organised like this:

What an IP KVM is, why I'd use one, and whether remote desktop isn't enough
Building an IP KVM with a Raspberry Pi + PiKVM
Building an IP KVM with a Raspberry Pi + BeaconKVM
Comparing the pros and cons, and which one I should choose

What is an IP KVM

KVM stands for Keyboard, Video, Mouse. From those three words you can roughly
tell what an IP KVM is: a piece of emulation that emulates the keyboard, mouse
and monitor of the target machine, and through that gives you control and a
picture.

Put simply, you visit the KVM device's IP in a browser and you get:

The controlled machine's screen, shown in the browser
Keyboard and mouse control of that machine, by using them in the browser

More advanced ones also have things like power control.

At first glance it looks the same as remote desktop, but once you look at the
emulated keyboard, mouse and monitor you can see the difference — these are
peripherals, and peripherals don't depend on the operating system. For example,
your monitor doesn't stop showing a picture just because your system crashed,
right? Take the classic Windows blue screen: on an IP KVM you can see the blue
screen, whereas with remote desktop software, once the system has blue-screened
you can't connect at all. Remote desktop software is a parasite on the
operating system — if the OS has a problem, it's unusable. And an IP KVM is for
exactly the case where the OS has a problem, the emergency case.

Looked at that way, I don't think IP KVMs and remote desktop compete with each
other. They both look like remote control, but the pain they solve is
different. Most of the time we use remote desktop to solve a convenience
problem; we use an IP KVM to solve an emergency, so you don't have to get in a
taxi or buy a plane ticket and go to the site.

IP KVMs are expensive partly because they need specific hardware, and partly
because they're worth so much to the user — the cost of a single trip is
already enough to buy one IP KVM, and everything after that is profit.

PiKVM

PiKVM is one of the better-known KVMs. Its defining
feature is that it's built on a Raspberry Pi: as long as you have one, you
don't have to buy their hardware, you can build it yourself.

That said, if you're a user without a technical background, building it on a Pi
isn't all that friendly — you might not even have heard of a Raspberry Pi, and
on top of that you have to sort out GPIO power, HDMI input and so on. The
barrier is fairly high, which is why they also sell their own hardware.

PiKVM is fairly simple to use (if it were complicated I wouldn't have wanted to
bother either). Let's look at roughly what installing it involves:

What you need

A Raspberry Pi 4B + a GPIO power lead + a capture card + a USB-C cable and
various other cables. For video capture I just bought a USB capture card
separately, rather than the HDMI capture board the official docs suggest.

Flash the system PiKVM officially provides

Once installed, find the Pi's local IP, open it in a browser, click KVM, and
the KVM opens. Very little difficulty.

Let's look at what it ends up like:

There really are a lot of features.

Now let me go through the pros and cons.

First the pros:

It's installed by flashing an image, so you don't have to fight with the software yourself — although this is also a downside, which we'll come to
The experience is good. From the screenshots above you can see it's sharp, and personally I found it smooth enough to use, but there are two cursors: one for the controlled machine and one for PiKVM
Lots of features. From the top-right menu you can see hotkeys, text paste, ATX and other optional features — this is probably why a lot of people choose PiKVM

Then the cons:

If it's flashed as an image, you need a separate device for it. You can't reuse a Raspberry Pi that's already in use
Local network access only. If you need remote access, you have to set up Tailscale or another VPN, and the barrier jumps immediately — most people won't manage it. Everyone's needs are different, but for me, if there's only local access then it's no different from remote desktop
It uses MJPEG, which you can think of as sending one image after another. The experience is good, but it takes a lot of bandwidth. That's fine on a local network; over the internet it gets expensive. Apparently if you buy their hardware it combines H.264 and MJPEG, but I haven't tried that

Overall its all-round capability is good, but it isn't very friendly to
beginners — and above all, if you have a strong need for remote KVM, PiKVM
leaves you to work out remote KVM yourself.

BeaconKVM

BeaconKVM is fairly new. We're a networking company that builds SD-WAN, so the
networking side gets more of our attention, and the device is adapted from our
own SD-WAN router. It has three main characteristics:

Remote access is built in, so you can do remote KVM. We come from SD-WAN and have global network resources, so remote KVM is a natural fit for us
It has its own web console where you can manage several devices at once: pick the device in the console and start a remote KVM session
It's simple. Very simple, especially once you've bought the hardware — plug in power and network, scan the QR code, and it's bound to your account

BeaconKVM also has a Raspberry Pi version as well as a hardware version. The Pi
version is mainly there to let users try the features and convert to the paid
version, but between the Pi version and the official hardware there is no
difference at all in software functionality — everything you get by buying
the hardware is supported on the Pi version.

Let's look at how to get the Raspberry Pi version running.

What you need

Exactly the same as PiKVM. No difference at all.

Install the software

We give you a one-line install command rather than an image to flash, which
means that if you already have a Raspberry Pi, you don't have to reflash the
system — it can live alongside your existing one. That's where it differs from
PiKVM.

curl -LO https://github.com/BeaconBeacon/KVM/releases/latest/download/beacon-pi.tar.gz
tar xzf beacon-pi.tar.gz
cd beacon-pi
sudo ./install.sh

After running the command you get a binding link. Open it and the device is
bound to your account.

Then reboot. We've written detailed instructions for all of this, so I won't
repeat them here: https://github.com/BeaconBeacon/KVM

Let's look at what using it is like.

In the web console you can see the LAN KVM and Remote KVM entry points, so you
don't have to go looking for its local IP. The one we mainly want to try here
is Remote KVM.

Sharpness and responsiveness are both fine, but there are relatively fewer
features than PiKVM — things like ATX, clipboard and CD-ROM aren't there, only
the core functionality.

Overall, if you don't want to fiddle too much and you have a strong need for
remote access, BeaconKVM may be the better choice. The barrier is fairly low,
but the product is fairly new and a lot of features aren't there yet; those can
only be added over time.

Pros and cons

We've gone through how each one is used above; here they are side by side.

	PiKVM	BeaconKVM
Installation	Flash their official image; the Pi has to be dedicated to it	One command; lives alongside your existing system
Remote access	Set up Tailscale or another VPN yourself	Built in, nothing to configure
Managing several devices	None. One local IP per device, remembered by you	A web console with all your devices in one list
Features	Plenty — ATX, clipboard, CD-ROM, hotkeys	Core functionality only
Maturity	Established, big community, you can search for answers	Fairly new, not much written about it

The hardware requirements are identical on both sides and both do LAN KVM, so
we haven't listed those separately.

If your Raspberry Pi is spare, the machines you want to control are on your
local network, or you already run something like Tailscale, pick PiKVM — it
does more, the community is mature, and when you hit a problem you can find how
someone else solved it.

If your Raspberry Pi is already running something else, or the machine you
want to control is somewhere else and remote access is a hard requirement, pick
BeaconKVM — the time it saves you is real, and the price is that it does
less, with a lot still missing.

Installing both is fine too. The hardware requirements are identical, so it's
just a matter of swapping the SD card.

How to access BIOS remotely

BeaconKVM — Thu, 10 Sep 2026 13:10:22 +0000

We're all familiar with remote desktop software — TeamViewer, Windows Remote
Desktop, and so on. Almost all of it works at the software level, running on
top of the operating system of the machine you're connecting to.

Which creates a problem. If the system has crashed, or something is broken,
remote desktop software can't be used at all. You could say the software is a
parasite on the operating system: if the system isn't running, the software
isn't either.

A KVM solves this class of problem. You can think of a KVM as a monitor,
keyboard and mouse emulated in software — it operates at the device level, and
it has nothing to do with whether an operating system is running. Here's an
example: your monitor doesn't go blank just because Windows failed to start.
A KVM is the same. Looked at that way, a KVM gives you BIOS-level access — you
can even watch the boot screen.

That is exactly the scenario BeaconKVM, which I build, is meant for: reaching
the BIOS remotely through a KVM, and fixing system-level problems from there.

In this article I'll go through how to use BeaconKVM to access the BIOS
remotely — enabling virtualisation, booting from USB, and from there
reinstalling the operating system remotely.

About BeaconKVM

I won't go into too much detail about BeaconKVM here. All you need to know is
that it's a product in the same category as PiKVM or JetKVM. What sets
BeaconKVM apart is that remote access is built in. It also comes in two forms:
commercial hardware, and a free build you can put together on a Raspberry Pi
4B.

The commercial version is aimed at non-technical users — you don't have to be a
programmer to have it working within five minutes.

More about BeaconKVM:

Let's begin

I've split this into a few steps:

Buy and set up the hardware — optional, there's a community build
Add it to your account
Reach Windows remotely through a browser
Get into the BIOS and change settings

Let's go through them one at a time.

Step 1: Buy and set up the hardware

Buy a BeaconKVM from our shop. If you'd rather
do it yourself and you happen to have a Raspberry Pi 4B, you can follow
our guide instead. The community build
is identical at the software level, but it takes a little more work to get
going.

Step 2: Add it to your account

When your BeaconKVM arrives, you'll find a QR code and a link on the back of
the device. Either one adds the BeaconKVM to your account.

Remote KVM only works once the device is added, because otherwise there's no
way to know it's yours. In other words, adding it to an account is both device
management and authentication.

Step 3: Remote KVM through a browser

Once it's added, you'll see the device and its online status in the
Beacon Console. If it's online, you can start
a Remote KVM session. On the Remote KVM screen you can pick a resolution and a
frame rate — the defaults are usually fine. Click connect, wait a moment for it
to get ready, and the target machine's desktop appears in your browser, exactly
as it would on a monitor. It's a strange feeling the first time.

Step 4: Get into the BIOS and change settings

Now for something remote desktop can't do. We restart the machine. Yes — we
restart it, and we get to watch the whole thing happen. That's fine, because as
I said earlier, we're a virtual monitor. Then hold Esc and you're in the
BIOS. The key differs between machines, so you'll need to know which one your
own board uses.

Once you're in the BIOS you can change whatever you need — enable
virtualisation, boot from USB, and so on. If your machine happens to have a USB
stick permanently plugged in with an OS image on it, you can boot from that and
reinstall the system remotely.

To sum up

You can buy the hardware, or build it on a Raspberry Pi 4B
No need to set up ZeroTier, Tailscale or anything similar for remote access
BIOS-level access, including reinstalling the OS remotely
No monthly fee

Broadly, BeaconKVM is aimed at non-technical users and small businesses. We try
to keep the barrier to entry as low as possible, and the design follows from
that principle.

I Built an IP KVM – BeaconKVM

BeaconKVM — Tue, 08 Sep 2026 02:22:08 +0000

I'm a programmer and entrepreneur from China. Before this, I built a SD-WAN product for the Chinese market—similar to Tailscale or ZeroTier—so my background is heavily in networking, WebRTC, and audio/video development.

Now, onto the KVM.

I love tinkering with hardware. My home is filled with routers, mini-PCs, NAS boxes, and all kinds of embedded gear. But I only have one monitor—and it lives upstairs with my main workstation.

That led to a few recurring headaches:

New devices go downstairs (networking closet, lab rack, etc.), but my monitor and desk are upstairs. Whenever something goes wrong during setup, I have to either haul the device up or drag the monitor down—just to see what's on the screen.
Traveling. Remote desktop software works fine when the OS is up and running. But the one time you actually need remote access is exactly when the system won't boot—and remote desktop can't help you there.
I wanted native remote KVM. No extra VPN layer, no added instability. Just direct, secure access.

Later on, I learned that many people use IP KVMs for power management, WOL, and other scenarios—but those aren't my primary drivers.

Given my background, I decided to build my own IP KVM software. And here's what it looks like.

What Makes This One Different

To be honest, I didn't study other KVMs extensively. I just designed this from a user's perspective. A few things stand out:

Built‑in Remote KVM – It comes with remote access out of the box, with no monthly subscription (at least for now).
You own the device – Full root access. Treat it like any other box in your homelab. We recommend lightweight usage, but it's yours.
You can use your own remote tunnel – Worried we might disappear someday? No problem. You can always install Tailscale, ZeroTier, or any other VPN software on the device. Even if we're gone, the hardware keeps working.

The most valuable part, in my opinion, is the Remote KVM. I've noticed that many KVM vendors are hardware‑centric and don't pay enough attention to the remote experience. I want Remote KVM to actually solve the pain of business trips and remote troubleshooting—and we already have enterprise customers using this in production.

How It Works Under the Hood

Feel free to skip this section if you're not into the technical details.

We're currently using our own SD‑WAN CPE as the base hardware. It comes with:

4 Ethernet ports
2 USB‑A ports
1 USB‑C port
Dedicated power input

On the software side, we stream video using both MJPEG and H.264.

MJPEG is smooth and low‑latency, but it's essentially a sequence of full JPEG frames, so bandwidth usage is high. That's why we force MJPEG on LAN—great experience, and local bandwidth is rarely an issue.
H.264 is used for remote access to save bandwidth. Since we're serving multiple users, lower bandwidth means better scalability. Our H.264 encoding is hardware‑accelerated—without that, the latency would be unacceptable. We spent a long time getting this right.

As for Remote KVM, it's basically a tunnel—but we added a security layer in front. You must log in first, and the device must be assigned to your account before you can access it remotely. No extra software to install; it all works right in the browser. And it's secure.

Try It Out & Share Your Feedback

Here's where you can find us:

Website: https://www.beacon-kvm.com
Shopify Shop: https://shop.beacon-kvm.com
GitHub: https://github.com/beaconbeacon
YouTube: https://youtube.com/@BeaconKVM
Discord: https://discord.gg/jjXN7H6WcH

If you're not ready to buy hardware yet, you can also build your own using a Raspberry Pi 4B—we've put together a guide here:

https://github.com/beaconbeacon/kvm

We'd love to hear your thoughts, feedback, and real‑world use cases. Help us understand what matters most to you—and what we can do better.