SimpleKVM: one keyboard and mouse across several PCs without a hardware KVM

The gap SimpleKVM fills sits between two machines and one monitor

The stated problem is narrow and worth stating plainly. A hardware KVM lets you move one keyboard, one mouse and one monitor between several computers, but the documentation points out that full KVMs are expensive, particularly the ones that support high resolution and high framerate. SimpleKVM takes the expensive part away. You buy a cheap USB switch, keep your monitor connected to every machine by cable, and let the program change which machine the monitor is showing.

The audience is therefore a home or small office desk, not a server room. A developer with a Windows workstation and a Linux box under the same desk, or someone who swaps between a laptop and a tower, gets most of the benefit of a KVM without the price of one. The USB switches the documentation lists as examples start at a few dollars and cover two or four ports, so the total cost added by this approach is small.

What the program does not do is replace any cabling. Every computer still needs its own display cable run to the monitor, and the monitor still needs enough inputs. The savings come from removing the switching box, not from removing the wiring.

DDC/CI input switching is the entire mechanism

There is no driver, no virtual display and no network protocol here. The documentation describes a loop: the program detects when USB devices connect or disconnect, or when hotkeys are pressed, and it then tells the monitor to change its input source using a DDC/CI command. Many monitors support DDC/CI, which is the assumption the whole design rests on.

The data flow is short and worth understanding before you install anything. A USB connect or disconnect event, whether produced by the switch or by a hotkey, acts as the trigger. The trigger becomes a DDC/CI command aimed at the monitor. The monitor changes its own input. Nothing travels between the computers, so the machines need no shared configuration and no knowledge that SimpleKVM exists.

Because the trigger comes from USB enumeration, the program has to be running on the machine that owns the switch, which is the machine the documentation tells you to run it on. That asymmetry matters: the other machines are passive targets. They do not need SimpleKVM installed, only the same monitor connection and a share of the USB switch.

Windows and macOS take different install paths, and macOS needs one extra click

The project publishes release artifacts rather than source builds for everyday use, and the documentation points at the releases section of the repository. On Windows the download is a single executable that you run. On Apple Silicon the download is a zip that you unpack and drag into Applications.

SimpleKVM.exe
SimpleKVM-macos-arm64.zip

On macOS the app is not notarized, so the system blocks the first launch. The documentation describes the manual path through System Settings under Privacy and Security, where a message about SimpleKVM being blocked lets you click Open Anyway once. It also gives a terminal alternative, which clears the quarantine attribute directly:

xattr -dr com.apple.quarantine /Applications/SimpleKVM.app

Expect two different first run experiences depending on the platform. The Windows path ends with a running program. The macOS path ends with a running program plus a security override that the operating system deliberately requires.

Run at startup writes into two different places on the two platforms

The startup option is reached through the settings button, where a Run at Startup option can be ticked. What that tick actually does differs by platform, and the documentation is specific about it. On Windows the program creates a shortcut in the Startup folder. On macOS it creates a LaunchAgent in `~/Library/LaunchAgents`.

Those are two different mechanisms with two different failure modes. A Startup folder shortcut is visible and easy to remove by hand. A LaunchAgent is a plist in a hidden directory, so if you ever want to know what is starting on login, that path under your home directory is where to look. The README does not document how to undo the setting from inside the application, so treat the two paths as the place to look if the program starts when you did not expect it.

There is no documented command line interface and no documented configuration file in the documentation. Settings appear to live inside the application window, which means this is a program you drive by mouse rather than by a script.

Monitor DDC/CI support is the boundary the README states out loud

The clearest limitation is also the one the project is most open about. The switching mechanism depends on the monitor accepting DDC/CI input changes, and the documentation qualifies this with the phrase many monitors support. If your display ignores DDC/CI, the program has nothing to send and nothing to accomplish, because there is no fallback path described. No network fallback, no keyboard-swap mechanism, no automatic detection of a failed switch.

There is a second practical limit that comes from the hardware, not the software. The cheapest USB switch the documentation links has a single input USB port, so it can only present one keyboard and mouse to one computer at a time. That is enough for the common case, but it means there is exactly one keyboard in the chain and the switch, not the program, decides which computer receives keystrokes.

Cable length is a third limit worth checking against your desk. The documentation describes computers connected to the monitor with cables and a USB switch between the mouse and keyboard. It says nothing about extending those runs or about distance limits, so a spread out setup is outside what the documentation covers.

Multiple monitors are answered with a yes and a screenshot

The documentation has a question about multiple monitors and the answer is Yes, followed by an image. That is the whole of the documentation on the subject, and it is thinner than the answer deserves, because multi monitor setups raise obvious questions about which input changes and in what order.

What can be said from the documentation is that the program handles more than one display, and the screenshot shows a two monitor arrangement. What is not documented is the sequencing: whether both monitors move together, whether one monitor leads and the other follows, how the hotkey maps to two screens, and how DDC/CI addresses are assigned per panel. The repository layout shows a C# solution with a SimpleKVM project and a SimpleKVM.Tests project, plus a packaging directory and a scripts directory, so the logic is unit tested to some degree, but the documentation does not describe what the tests cover.

If you run two monitors and want to know the switching order, plan to determine it by trying it rather than by reading. Do not assume the behaviour you saw with one display carries over unchanged.

The lineage traces to haimgel's display-switch program

The documentation credits its inspiration directly, pointing at haimgel's display-switch program. That is the honest alternative to look at when weighing SimpleKVM, because the comparison is about approach rather than about feature lists.

The documentation only says SimpleKVM was inspired by it, so the details of how the two differ are best checked in the upstream source. What is clear is SimpleKVM's own control model: it reacts to USB connect and disconnect events and to hotkeys, so a physical switch becomes the trigger for a DDC/CI change.

That difference has a practical consequence. SimpleKVM fits a shared desk where the keyboard and mouse physically move between machines, because the switch press and the input change happen as one event. The MIT licence covers the project, and the documentation points at the upstream project it grew from, so anyone deciding between the two approaches can read the original source alongside this one.

Editorial conclusion

SimpleKVM suits a single desk where every machine already reaches the same monitor and a three dollar USB switch can carry the keyboard and mouse. It does not suit long cable runs, machines in separate rooms, or displays without DDC/CI, since the README names that limitation itself. Before adopting it, confirm that your monitor accepts DDC/CI input changes, that your USB switch enumerates a connect event the program can observe, and that the run at startup setting writes where you expect it to, which is a Startup folder shortcut on Windows and a LaunchAgent in ~/Library/LaunchAgents on macOS.

Frequently asked questions

Official sources

1. fiddyschmitt/SimpleKVM on GitHub
2. Issues
3. License: MIT
4. README
5. Releases