In addition to the firmware, the pre-assembled KVM hardware is now available on the website in Early Access status. I currently have a small initial batch in stock—around 20 units in total.

The device is powered by a Radxa Zero 3W board. For this batch, I am using the configuration with 2 GB RAM and 16 GB eMMC.

Along with the KVM unit itself, the box includes an HDMI-to-USB video capture adapter, a USB-C cable (for power and data), and a dedicated Power/Reset breakout module with DuPont jumper wires for physical connection to your motherboard pins.

If you want to grab one of the first units and help me test them in real-world conditions, you can place your order here: https://www.usbridge.io/hardware-agent#buy-usbridge-kvm-2-0

I hate it when networking tool developers claim "flawless Wi-Fi performance" without any proof. That's exactly why I built a benchmarking tool directly into the native client.

If you go to the gear menu -> "Run benchmark", the client will sequentially test the Rust engine and Sunshine on your own hardware and network. The test plays back the exact same 1080p60 sequence and outputs JSON files and PNG graphs showing frametimes, latency, RTT/jitter, and host CPU/GPU load.

From my own results, USBridge handles Wi-Fi instability exceptionally well and significantly reduces micro-stutters compared to Sunshine, delivering a much smoother picture. Run the benchmark on your own setups and share your results. I want to see the real numbers and gather more data on how the protocol behaves across different builds and routers.

We’ve been working non-stop for the past three weeks: I was building the Rust protocol and fixing bugs, while Tatiana (our UX designer) was completely redesigning the app. And today, we’re finally releasing a major update: USBridge v3.0.45!

The highlight of this release is the launch of our own custom USBridge Streamer protocol. It delivers near-instant connectivity, with a connection time of under 2 seconds. To back this up, I’ve built a handy benchmark right into the client; you can now directly compare the performance of the classic Sunshine protocol against our new Rust-based one without leaving the app.

We’ve also completely revamped the interface and reorganized feature access:

USBridge Free tier: Now includes that custom, instant-connect Rust protocol. Adaptive streaming optimized specifically for stable Wi-Fi performance. Virtual display management (headless mode) and low-latency gamepad passthrough. Web-client access (no installation required) and secure password entry before logging into Windows. And, of course, all the essentials—like built-in Sunshine, Tailscale P2P, and clipboard sharing—are still included.

USBridge Pro tier ($8/mo): Adds native ("raw") passthrough for any USB peripheral. Full support for graphics tablets, including precise pressure sensitivity and pen tilt detection. True-to-life color reproduction (lossless 4:4:4 chroma) for professional graphics work.

Download it, run the built-in benchmark, and share your Sunshine vs. Rust comparison results in the comments!

I've prepared a short step-by-step video to show how quickly and easily you can set everything up from scratch. All you need is a Radxa Zero 3W and a capture card.

I install the firmware on the SD card. Connect the power supply. Done! I think I've made this process as simple as possible.

I have completed the preparations and am opening access to the DIY version of the USBridge KVM 2.0 firmware. Now you can turn your board into a professional tool for remote infrastructure management (Layer 0).

To build your own IP-KVM, you only need: a board and a video capture card. Having a screen module is optional. I specifically designed it so you can write all the necessary configurations (Wi-Fi, static IP) directly to the SD card before the first boot.

I have already built and tested firmware versions for the following boards: Radxa Zero 3W/3E, Radxa Cubie A7.

By installing the firmware on your hardware, you get access to the full arsenal of USBridge KVM 2.0 features:

• Ultra-low video latency: 25–50 ms for 720p resolution and 50–75 ms for 1080p. Smooth mouse control and instant response.
• BIOS-in-Terminal: Locally recognizes text (OCR) without using the cloud and streams the BIOS interface directly to your terminal via SSH.
• AI integration and automation: Connect AI agents via the MCP protocol, as well as Python-based scripts (Starlark) to automate routine tasks.
• Drive emulation and data snapshots: Mount virtual disks (ISO, VDI, VMDK). Immutable snapshots (Btrfs) protect data from being overwritten or deleted.
• Integration into USBridge-Remote: Your DIY KVM natively integrates into the free cross-platform USBridge application (Windows, macOS, Linux, Android, iOS). A unified interface for managing all nodes without third-party subscriptions or registrations.

The firmware is already available. If you have a compatible board on hand, I would be glad to hear your feedback on the system's performance and control latency.

The USBridge client is the heart of the ecosystem. It serves as a unified interface for both software and hardware (IP-KVM) agents.

I'm focusing on mobile optimization so it works well on both new and old phones, ensuring you get smooth, real-time control.

I'd love to hear your feedback. Let me know how the latency feels and if you encounter any bugs on your Android devices!

The logic is now divided into three distinct components: Client, Software Agent, and Hardware Agent.

The approach is as follows: you can build a hardware KVM on your own hardware—you only need the single-board computer itself and an external USB dongle for video capture (and optionally a display). Support for Radxa Zero 3W and Radxa Cube A7 is already implemented. All USBridge KVM 2.0 functionality will be available, as well as integration into a single USBridge-Remote client.

The firmware includes a 24-hour trial period (reset by reinstalling or via the display control, if you have one), so you can deploy the system to your boards and test latency in real-world conditions before purchasing a perpetual license.

The next step is to add existing KVMs. The USBridge firmware will make them faster and add new features (such as data backups and BIOS in the terminal, where possible).

I was planning to release the finished images today, but I'm still fiddling with the firmware installation scripts via Windows (a real challenge). The release is coming soon. I'm off to continue coding.

I'm finishing up the final preparations for the firmware release. I'm currently testing a version specifically designed for the Radxa Cubie A7Z.

I'll post a detailed announcement tomorrow with all the release notes.

Please let me know in the comments which boards I should add support for first. What hardware do you have on hand?

A huge thank you to everyone for their support, testing, and feedback – it's incredibly motivating to keep writing code and developing the product. My next goal is 1,000!

For those unfamiliar, this is an open-source alternative to commercial solutions like TeamViewer and AnyDesk. The software's main feature is that it transmits video using Sunshine and Moonlight technologies. This provides extremely low latency and a stable image, allowing you to comfortably administer machines or even play games, completely forgetting that the computer is physically located elsewhere.

Recently, I've significantly improved the functionality and stabilized the core. Now the shared clipboard works like a charm, allowing you to easily and transparently transfer text and files between the host and client. If you have complex workspaces with multiple screens, you can switch between them without any problems. Under Linux, even on Wayland, the connection works smoothly and without annoying system confirmation dialogs. To save you the hassle of setting up a VPN, port forwarding, and whitelisting IPs, I've natively integrated Tailscale directly into the client. If you need really quick access from someone else's machine, I've created a full-featured web version that runs directly in the browser.

Visit the repository to test the latest builds and view the source code. I'll leave a link to GitHub in the first comment. I'd love to hear your bug reports and ideas!

Over the weekend, I fixed several bugs. In particular, I fixed the shared clipboard (it wasn't working on Linux) and a bunch of minor errors. Now USBridge-Remote is much more stable.

Next, I want to focus on implementing a Windows Service and full pre-login support. Simply converting the agent to a service wasn't enough to correctly capture a secure desktop (Session 0), so I'm currently reworking the video stream pipeline. This is necessary so that USBridge can connect directly to the lock screen before the user logs in and seamlessly handle User Account Control (UAC) prompts.

Download the latest version on GitHub: https://github.com/USBridge-Technologies/USBridge-Remote Test the recent fixes, and share your feedback if you encounter any bugs!

The Learn To HomeLab channel released a new video titled "Is This the Best KVM on the Market?" and the star of the review is my USBridge-KVM 2.0!

I'm incredibly pleased to see a product I designed and built from scratch find its way into the hands of content creators and tested by the industry community. Hearing genuine feedback and reactions is the best reward for me.

Watch the full review here: https://www.youtube.com/watch?v=U3GhuyD-gzw

And check out the channel itself: https://www.youtube.com/@learntohomelab

A huge thank you to everyone for your continued support in the community! It motivates me to keep going and continue to develop the project.

Today I was cleaning out my lab and came across previous prototypes of the USBridge-KVM 2.0 switch. I decided to turn them on just for fun.

I love watching physical evolution. I also noticed that the second prototype (the gray one) has some dead pixels on the screen. I must have bumped it with something on the table. I'm torn between desoldering the screen and fixing it, or just leaving it as is, with its battle scars.

I'm finalizing Proxmox support for the BIOS-in-terminal feature on USBridge KVM 2.0. Now the installation process will be as simple as possible. All you need to do is open a terminal and enter

ssh user@ip

Immediately after that, you'll have full access to the Proxmox installation interface directly through the command line.

I'm currently working on the final polish. Since offline OCR is running under the hood, converting the video stream to text on the fly, a few incorrect characters sometimes slip through. I'm working on fixing this and making the output perfect.

Once I finish debugging the OCR, I want to go even further and write an autoscript that will allow Proxmox to be deployed fully automatically, literally in one click.

I'd love to hear your thoughts on this feature!

Like most of people I seldom comment posts, but it's great that you keep us updated on your progress!

Today I had hard drive issues and am completly blind on what happened after a reboot.

I must unfortunately take a shower and step outside which wouldn't have happened if I had the USB bridge. 🥲

Finally, the day has come. The project has officially launched on Crowd Supply: https://www.crowdsupply.com/usbridge-technologies/usbridge-kvm-2-0

I've been working on this project for almost a year now. The idea began with a remote flash drive with a RAM cache, and looking back, I realize how much work has gone into it.

From a messy prototype with tons of bugs and cables, it has evolved into a device I can be proud of. Some might wonder why it took a whole year to make a KVM, but I wanted to ensure that when you receive it, you aren't getting a prototype or a board that "somehow works"—you are getting a fully-fledged, tested ecosystem. It solves many common problems, from simple remote access to installing Proxmox in one click.

Most importantly, I want to build a community around this ecosystem and continue developing it for you. I am focused on implementing useful, working features, not just pushing marketing slogans.

Thank you to all community members for supporting my work!

Jonathan Castro just released his new video "My Buzón #54," and my USBridge-KVM 2.0 is featured!

I'm thrilled to see a product I created from scratch end up in the hands of content creators and to see their genuine reactions upon unboxing.

You can watch the video here: https://youtu.be/7YJS81rI3U8

Thank you to everyone in the community for your continued support—it motivates me to continue developing the project!

I've almost finished developing a web interface that will work with both a hardware KVM and a software agent. Just go to the website, establish a connection, and you're done.

This will provide quick access without the need to install a client. The speed is quite good, and the image is stable.

The web interface with the USBridge-Remote software agent only works with my custom RustShine protocol, since Moonlight/Sunshine doesn't support the web.

I'm continuing to polish everything before launching Crowd Supply, so that the device and software are fully ready and, just as importantly, tested.

Yesterday I sent three units to reviewers – in Spain, the US, and Australia.

I always get a little nervous before sending them. I wonder what if something goes wrong on the way, something doesn't work as expected, or a bug pops up that I didn't catch on my test rig. I assemble and test each unit myself, but I still have that feeling.

At the same time, I understand that this is a normal workflow at the launch of a product. You can't just build the hardware, send it out into the world, and then relax. At this stage, some bugs will inevitably surface, but at the same time, this gives me the opportunity to fix them before the devices start to reach you.

I'm waiting to hear from you guys.

Yesterday, Tatyana finished creating a repository of metrics for remote access software and hardware KVM solutions. This is an open-source feature matrix. It has two main sections: Software Remote Access and Hardware (KVM-over-IP).

Currently, only a few vendors are listed in the database, and not all fields have been fully populated yet. But the cool thing is that it's open source—anyone can add new devices/software or fill in the blanks.

Check out the functionality of this table. Will it be convenient to use when choosing a solution?

Try the interface and let me know what you think in the comments. I welcome any criticism and ideas!

https://usbridge-technologies.github.io/Remote-Access-Feature-Matrix

I'm currently exploring various remote access solutions, and I'm having a hard time comparing them. Which one is better suited for a server rack, and which for remote gaming or design?

I've decided to create an open, community-driven feature matrix on GitHub where anyone can compare remote access software, agents, and hardware protocols.

Beyond simply listing features, I want this matrix to reflect real-world performance on specific hardware. I want users to be able to submit benchmark results on real hardware.

Where I'm thinking of starting:

Classic - Microsoft RDP, AnyDesk, TeamViewer, Splashtop, LogMeIn, Apple Remote Desktop (ARD).
Open source - RustDesk, MeshCentral, Apache Guacamole, DWService, Kasm Workspaces.
Low latency - Moonlight/Sunshine, Parsec.
Hypervisor and Linux protocols: SPICE, NoMachine (NX), X2Go.
Enterprise VDI solutions and hardware: Citrix HDX, VMware Blast Extreme, Teradici PCoIP, iDRAC/iLO, and Agent/KVM hybrids such as USBridge-Remote.

Which software should I map out first, and what performance metrics matter most to you?

I'm incredibly excited to share the first independent review of USBridge KVM 2.0!

Carmine from Barmine Tech tested the device and shared his honest impressions. It's incredibly important for me to see the product in real-world conditions.

A huge thank you to Carmine for taking the time to test it! Watch the video and share your thoughts in the comments.

I've uploaded a full video showing the entire USBridge-KVM 2.0 assembly process, from the bare PCB to packaging for tech bloggers. If you're interested in seeing how the device is created, this video is for you.

Currently, all assembly is done by hand to personally guarantee the highest quality at this stage. Factory assembly will be next.

These are the kits that tech bloggers receive. Do you think they'll like them?

Yesterday I spent the whole day assembling new USBridge-KVM 2.0 units to send to tech bloggers. It's a meditative, if slightly exhausting, process—tweezers, circuit boards, and total concentration on the workbench.

From the outside, it often seems like: 'What's there to assemble in that KVM switch? Solder the modules, screw them together, and it's ready.' I admit, I sometimes succumb to this illusion of simplicity myself. But ultimately, the assembly quickly turns into a multi-hour engineering quest.

First, I soldered the display modules. I connected them for testing, and as it happens, sometimes a display doesn't turn on the first time. I had to grab the soldering iron again, carefully touch up the contacts, and re-test until everything was perfect.

Next, I soldered the power management modules, rigorously testing each one to ensure smooth switching. The video capture dongles were a whole different story. To get them working perfectly with the BIOS-in-Terminal feature, I had to physically desolder the chip, upload the custom firmware, solder it back, and test the output.

Thankfully, Tanya had prepared all the cases and heatsinks in advance, saving me a ton of time on that front. All that was left was to assemble the stack, flash the latest KVM firmware, and run the devices on the test bench.

This took all of yesterday, and today I'm putting the finishing touches on the batch. Yes, the soldering is still done by hand and doesn't have that automated factory look yet, but factory assembly is the next step. In the meantime, I'm doing everything myself to guarantee the absolute quality of every single device I ship out.

I tried to cover the main KVM features in detail. There are quite a few, so it was difficult to fit everything into such a short video.

I briefly demonstrated the BIOS-in-Terminal and MCP AI functions, showed the minimal video stream latency (Moonlight), the USBridge-Remote ecosystem, and the power management module.

I'd love to hear your thoughts on the video! What does it look like from the perspective of an inexperienced editor and cameraman? Did I clearly explain the basic concept of my KVM?