u/Lopsided_Mixture8760

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've been developing my compact IP KVM, the USBridge-KVM 2.0, for almost a year. Here's how the device has evolved, from the first prototype to the final device. Initially, I wanted to create a simple remote flash drive with RAM cache, but the project has grown beyond a typical KVM. I developed a unique BIOS-in-Terminal feature that converts BIOS video to text in real time, which is handy when the internet connection is poor or for automating processes.

I implemented the Moonlight gaming protocol, achieving a minimum of around 22 ms, and now when working via KVM, it feels like I'm sitting at the same computer. The entire emulation is ready, as is the power-on/server-reboot control. The board architecture and firmware code are debugged, I'm finishing final testing and preparing for production at the factory.

I built an offline OCR "BIOS-in-Terminal" engine into the hardware IP-KVM (USBridge KVM 2.0). It intercepts the raw HDMI video output from the server and converts it on the fly into an interactive text stream.

Right now, I am finalizing support for the Proxmox installation environment. Now, all you need to do is open a terminal and type ssh user@ip to connect to the KVM. You immediately get the Proxmox installer interface directly in your command line.

Because the KVM translates the video output into pure, structured text rather than a video feed, it completely changes how you interact with the server. I am currently finishing up an automation script that interacts with this text stream. The script simply reads the text output and sends the appropriate keystrokes. My goal is a fully automated, 1-click Proxmox bare-metal deployment script running entirely over SSH.

The KVM also operates in standard video mode (with minimal latency, using the Moonlight/Rust-Shine protocol); the terminal mode is just an addition. What do you think, is it convenient to install Proxmox directly from the terminal?

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!

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!

I'm developing a hardware project called USBridge-KVM 2.0, and I chose the Radxa Zero 3W as the base. I'm pleased with the board's performance, but there are some cooling issues. This is the second reviewer complaining about the noisy cooler.

For those interested in how it sounds, here's a video - https://www.youtube.com/watch?v=7YJS81rI3U8

Initially, I wanted to use a simple copper heatsink, but it wasn't powerful enough to handle the video stream. It got as hot as a frying pan.

I decided to switch to active cooling. All that's available on the market are a couple of mini coolers, and I chose the most powerful one with turbocharging, so to speak. It's 4mm thick. And it really does its best.

I'll implement fan speed control later, which should make it quieter. Also, is it just me, or will it settle in and become quieter after running it for a week?

How do you generally handle cooling for these boards? Are there any other cooler options I haven't found?

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.

I'm developing USBridge-Remote, an open-source, cross-platform remote access solution. It's powered by Sunshine/Moonlight, a protocol used for cloud gaming. It offers incredibly smooth video and minimal latency.

It also has everything you need for a comfortable experience: multi-monitor support, shared clipboard, and Tailscale (for a secure connection). Another interesting feature is that Wayland doesn't display connection confirmation messages; perhaps this will be useful for someone.

No registration required, no limits. The code is completely open source: https://github.com/USBridge-Technologies/USBridge-Remote

If you have any questions, please ask, and I'd love to hear your suggestions for what else should be added.

I've been developing USBridge-KVM 2.0 for almost a year, based on a rather unusual idea: converting BIOS video into text.

Most IP-KVMs simply stream video. I did it differently: the device intercepts the raw HDMI signal at the hardware level, runs it through local OCR, and converts the entire graphical BIOS/pre-boot screen into an interactive text stream, which you can access in the Terminal via SSH. It's completely offline.

You can select and copy serial numbers or error codes even on a broken connection. You can also connect AI agents via MCP (Model Context Protocol). The agent reads the terminal, navigates the BIOS menu, runs diagnostics, and mounts drives.

During this time, I also completely open-sourced USBridge-Remote, a software solution for remote access (Win/Mac/Linux/Android/iOS). This wasn't part of my original plan, but the hardware KVM still needed some kind of software layer. I decided to make it free and open source; it works even without the hardware itself.

You can test the code here - https://github.com/USBridge-Technologies/USBridge-Remote

I'm currently preparing to launch a campaign on Crowd Supply. I'm both nervous and excited – for the first time, I'm taking something from "something I built for myself" to "something you can actually order."

If you have any questions about the OCR pipeline, MCP integration, or production, I'll be happy to answer them.

I need real-world hardware testing under harsh conditions, and your home labs are the best place to put USBridge-KVM 2.0 to the test.

The idea is simple: post photos of your server racks and setups in the comments to enter (one entry per account). To keep things 100% fair and avoid any vote manipulation, the winner will be chosen entirely at random using RedditRaffler on August 3, 2026, at 8:00 PM EST. The selected person will receive a free device (shipping included). If the randomly selected user didn't include a photo of their setup, I will reroll until a valid entry is chosen.

Features: BIOS-in-Terminal local BIOS recognition (OCR), minimal video stream latency, virtual disk support, and data snapshots. All of this is integrated into the unified cross-platform USBridge-Remote ecosystem.

I'll send the winner a complete kit with everything needed for operation, including a hardware power management module. This will be the very first unit ever to be used by a real user, so I guarantee maximum technical support and personal setup assistance from me.

Show me your racks! I'm waiting for your photos in the comments.

I'm the developer of USBridge-Remote, a free and open-source tool designed to manage remote machines and home lab infrastructure without the need for proprietary third-party cloud services.

It uses built-in Tailscale P2P tunneling, allowing secure access to remote hosts through NAT/firewalls without exposing ports to the public internet.

Moonlight integration for high-performance desktop access.

It's designed specifically to handle Wayland capture/input on modern Linux distributions without annoying permission pop-ups.

The project is currently in beta. I'd love to hear feedback from other home lab users about network setup or features you'd like to see. GitHub repository:

https://github.com/USBridge-Technologies/USBridge-Remote

I originally developed this app for my custom KVM-over-IP, but it turned out to be much more effective than existing solutions, so I decided to make it fully open-source for the community. No constant limitations, no mandatory account registrations, and no dependence on third-party cloud services.

If your mini lab needs direct, independent access over your local network or via Tailscale (with ZeroTier planned for the future), I recommend giving it a try. It features native Moonlight and Sunshine protocol integration, delivering ultra-low latency and frame rates up to 240 FPS. Wayland (Linux) works right out of the box without screen capture issues or constant permission pop-ups.

Over the weekend, I finished working on a two-way shared clipboard: copying and pasting text, transferring images, and sharing files between local and remote machines is now fully functional.

Ready-to-use beta versions for Windows, macOS, Linux, and Android are available in the repository, and the iOS client is already live in the App Store.

GitHub: https://github.com/USBridge-Technologies/USBridge-Remote

I’d love to hear your feedback!

I'd like to share with you USBridge Remote, a completely free and open-source client I'm developing for managing remote machines.

In keeping with its open-source philosophy, the project has no session or connection limits, requires no accounts or registration on target machines, and contains no telemetry or background data collection.

For low-latency video, the streaming engine uses built-in Moonlight integration. Security and networking are provided by built-in Tailscale P2P tunneling, allowing you to connect securely over the internet without the need to configure port forwarding or firewall rules. Additionally, I've developed a Linux agent with Wayland support, meaning it handles full-screen capture and input data out of the box without constant, annoying permission pop-ups.

The project is currently in beta. I'd love to hear your feedback, so if you have any suggestions or find any bugs, please let me know.

GitHub repository: https://github.com/USBridge-Technologies/USBridge-Remote

I'm creating this software because I'm tired of the limitations, mandatory registration, and shortcomings of existing remote access options.

This project is especially relevant for home lab enthusiasts who need a completely independent remote desktop access solution that prioritizes the local network, without relying on third-party cloud infrastructure or external relay servers.

Its distinguishing features include integration of the Moonlight protocol for low-latency, high-frame-rate video streaming. Native support for Wayland (Linux). It works out of the box without permission pop-ups. Tailscale integration. Direct P2P connections without worrying about port forwarding on your router or setting up complex external tunnels. (Integration with ZeroTier is also in development.) A unified ecosystem with USBridge-KVM 2.0. The software can manage both agents and my hardware IP KVM from a single interface.

Completely self-hosted, free, and open-source.

Ready-to-use beta versions for Windows, macOS, Linux, and Android are available in the repository, and the iOS client is already available in the App Store. I'm currently fixing bugs and stress-testing the release. The source code and builds are on GitHub: https://github.com/USBridge-Technologies/USBridge-Remote

I'd be happy if you tested it on your servers and home labs. I'm also open to any feedback on the architecture!

Disclaimer on the use of AI: During development, I used LLMs primarily as an advanced debugging tool, optimization of specific algorithms, and boilerplate code generation. The system architecture, the main integration with Moonlight, and the direction of the codebase were designed and written by me.

I've finally open-sourced my USBridge Remote project on GitHub. I developed this software as an alternative to traditional remote desktops like RustDesk or AnyDesk, because I was fed up with their flaws and constant limitations. It was crucial for me to release a pure P2P tool without mandatory registration, paid subscriptions, or session limits.

A key feature is the integration of the Moonlight protocol, which ensures high frame rates with virtually no ping.

Natively solved the Wayland issue in Linux. If you've used other remote desktops, you know how they spam permission confirmation dialogs every time you connect. My agent works with Wayland out of the box, capturing the screen and injecting input without any pop-ups or workarounds. The connection is made directly through the built-in Tailscale integration, so you don't have to worry about tunnel security, and you don't have to forward ports on the router. Plus, the software can manage not only software agents but also my hardware IP-KVM cards from a single interface.

The code is fully accessible, with ready-to-use beta versions for Windows, macOS, Linux, and Android already in the repository, and the iOS client has been approved in the App Store. I'm currently actively running stress tests and fixing bugs on the fly, so releases may be coming out quite frequently in the coming days. Feel free to grab the project, tinker with the source code, and test it on your servers. I'd appreciate any feedback on the architecture.

Source code and builds on GitHub: https://github.com/USBridge-Technologies/USBridge-Remote

A few days ago, I published a post about my DIY IP-KVM project, in which I integrated Moonlight streaming with Rockchip hardware encoding. Many of you in the comments asked for real-world latency and responsiveness tests, so over the weekend we recorded a video to accurately measure performance.

Here are the real-world latency numbers I get with this configuration:

At 720p: 25 ms to 75 ms

At 1080p: 50 ms to 100 ms

Streaming through a secure Tailscale tunnel adds virtually no noticeable overhead.

On the left is the target monitor with an online stopwatch, connected directly to the KVM switch.

On the right is the client laptop receiving the live video stream. With this level of responsiveness, navigating the BIOS or performing remote system recovery feels incredibly smooth—almost like connecting the monitor directly.

I'm currently finalizing the code for the USBridge-Remote desktop agent app (which also supports Wayland out of the box) and plan to release it as open source in the next few days.

Let me know what you think!

A couple of weeks ago, I received an email from a completely blind software engineer. He explained that BIOS and pre-OS accessibility has been a huge problem for almost 15 years-ever since specialized hardware like the PC Weasel became obsolete. Screen readers don't work at Layer 0.

This made me take a second look at my current project-a hardware IP-KVM (USBridge-KVM 2.0). Its distinctive feature is that it intercepts the raw HDMI signal and converts the BIOS visual interface into a clean, interactive text stream accessible through a standard SSH session.

My automation engine also outputs a JSON stream with the screen state, including the text and colors for each character.

I originally created this data interface for AI agents (MCP) so that a neural network could "read" the screen and perform hardware checks. But now I understand that the same JSON/SSH stream can be passed to a screen reader so it can announce active BIOS menu items in real time.

I didn't create this device with accessibility in mind. It's simply a side effect of my desire to have a reliable text interface for script automation.

How useful is this functionality in practice? And how much will it help a blind person navigate the BIOS and deal with Windows blue screens of death?

I'm back with new latency and performance test results after enabling the Moonlight protocol on my USBridge-KVM 2.0.

I launched Hollow Knight: Silksong. It's actually playable!

Performance metrics: 1080p at 30 FPS is smooth and stable, 720p at 60 FPS is very responsive to fast-paced gameplay.

The current Radxa board (RK3566) physically can't hardware encode anything higher than 1080p. This is a hard limitation of the chip, so I squeezed everything possible out of its multimedia pipeline.

I'm currently considering a Pro version that could handle 4K at 60 FPS. This will require a more powerful and larger single-board computer. I currently have an Orange Pi 5 Max at home. I want to connect it and try running some tests to make sure it's up to the task.

What do you think? Would you be interested in a 4K Pro version, or is 1080p/720p more than enough for your lab needs?

Initially, I created my USBridge-KVM 2.0 as the ultimate tool for Layer 0 administration—the device can convert BIOS and Pre-OS video capture into interactive text in real-time and feed it into an SSH terminal (BIOS-in-Terminal).

But that didn't seem like enough to me. I decided to squeeze the maximum out of the multimedia capabilities of the Rockchip RK3566 chip and launch full-fledged game streaming via the Moonlight protocol.

Historically, Moonlight doesn't have native Rockchip MPP/RGA support. If you run the software without optimization, the processor instantly goes into thermal throttling due to software pixel conversion, turning the stream into a slideshow.

I rewrote the video pipeline; now the raw YUYV422 stream from the capture card goes directly into the Rockchip RGA 2D engine, where it is converted to NV12 in microseconds. These frames then immediately drop into the H.264 MPP (Media Process Platform) hardware encoder. The entire stream is processed on-chip via a DMA buffer.

The result is a perfectly smooth 1080p @ 30 FPS, 720p @ 60 FPS stream. Input latency has dropped so much that now, through my IP-KVM, you can not only admin servers without that annoying "jelly" cursor but also comfortably play dynamic platformers.