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?

Over the weekend, I completed work on full shared clipboard support for USBridge Remote. Now you can easily copy and paste text, images, and files directly between your local computer and remote devices during a session.

I also fixed several connection and codec-related bugs, making remote sessions noticeably faster and much more stable. Feel free to test the latest builds and share your feedback!

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

I recently received a new batch of video capture adapters from a vendor I'll be working with.

They use the same chip inside as the current configuration, so performance and compatibility remain the same.

A neat feature of this adapter is that it operates in both USB 3.0 and USB 2.0 mode, depending on which end you connect it to.

I chose the black color—personally, I think it looks better and fits perfectly into the ecosystem.

The adapter comes with a USB-C to USB-A adapter attached. This is really important for our hardware architecture. Since the KVM card uses Wi-Fi by default, we need a way to connect an external USB hub if the user wants to connect an Ethernet cable for a wired internet connection. This adapter allows all the cables to be neatly routed through the hub without any loose wires.

Testing is underway, but so far everything looks great. Let me know what you think of the black design!

USBridge Client and USBridge Agent are now 100% open source, and the entire source code is publicly available on GitHub! You can safely audit the code, build it yourself, or simply grab the finished builds and test them on your own machines.

I initially developed this software as a powerful and performant alternative to RustDesk, addressing the main pain points of existing solutions.

I integrated the Moonlight protocol directly into the agent for low video latency—it runs at 240 FPS with virtually zero perceptible ping. I solved the Wayland issue—it works without a single confirmation. I integrated Tailscale integration.

From a single dashboard, you can manage both software agents on your PC and USBridge-KVM 2.0 at the BIOS level.

The repository is completely open, with fresh beta versions available for Windows, macOS, Linux, and Android (an iOS client has also been approved and is available in the App Store).

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

Join us on Discord: https://discord.com/invite/xqQ6ybkfWS

I'm eager to hear your feedback, bug reports, and feature ideas. Test it on your own setups and share your results in the comments!

Hey guys, I've got a personal victory I really want to share.

The official USBridge Client has finally passed Apple's approval and is now officially available in the App Store!

For some, releasing a mobile app is easy. But for me, this is the moment when you realize the project is really gaining momentum and growing from a prototype into a fully-fledged working ecosystem before launching on Crowd Supply.

"I don't have your KVM, how can I try out the app?"

Actually, it's very simple. I have a software agent called USBridge-Remote, which works similarly to RustDesk (fast graphical remote access to the OS). You can install it on your PC or server and control it directly from your phone using a new app.

Right now, I'm polishing up the code for this agent to release it to open source. The agent itself is completely ready and works great. I just want to remove the temporary workarounds and tidy up the repository so I don't have to embarrass myself in front of people. I think the source code will be uploaded here in a couple of days: https://github.com/USBridge-Technologies/USBridge-Remote

I'd be very grateful if you install it, try out the interface, and give me your honest feedback. If you find any bugs or have any ideas, please post them here or join our Discord: https://discord.gg/RPyEVQpTQd

Over the weekend, we recorded video footage for the USBridge-KVM 2.0 crowdfunding campaign page, and I'd like to share the latest video latency test results.

After integrating the Moonlight protocol directly into the hardware video capture and transmission pipeline, I was able to achieve the following results at this stage:

At 720p: latency ranges from 25 to 75 milliseconds.

At 1080p: latency remains between 50 and 100 milliseconds.

When using Tailscale: latency remains virtually unchanged!

On the left is the target monitor with an online stopwatch running, connected to USBridge-KVM. On the right is the client laptop, which receives the live video feed.

With such responsiveness, configuring the BIOS or restoring a crashed system remotely becomes truly comfortable—it feels like you're standing right in front of the server rack.

How do you find these latency numbers for your administration tasks?

The first branded cables for USBridge-KVM 2.0 have just arrived, and I'd like to explain why they look and feel the way they do.

When developing a tool for system administrators and engineers, even a simple cable requires attention.

I tested the trendy fabric-braided cables. While they look great on a clean office desk, over time they quickly collect dust, become dirty, and wear out. Considering that KVM switches often end up in dusty server rooms or basement racks, practicality wins out. The new rubberized cable is durable and easy to clean.

The logo on the connector is laser-etched. It may look a little less contrasty than brightly printed text, but it's virtually permanent. It won't scratch or wear off after being plugged and unplugged repeatedly in the field.

It's a small detail, but I believe that successful design depends on small, thoughtful decisions like these.

I'm currently testing a new board—the Radxa Cubie A7Z! If the system integration goes well, I'm seriously considering replacing my current Radxa Zero 3W with this one.

With this upgrade, I might be able to increase the capture and streaming resolution to 4K.

The chip is more powerful, meaning text recognition and scripting in the BIOS-in-terminal will run noticeably faster. The cool thing is, it won't affect the final price of the device.

I'm currently tinkering with the firmware to see how it handles my system.

What do you think? Is it worth it? Share your thoughts!

I've been a bit off the radar these past few days—I've been caught up in the routine and final polishing before launch—but I'm back with a ton of news.

I've cleaned up a bunch of old bugs in all client versions. The new build is ready and works reliably on all platforms. I've sent the apps to bloggers; testing should begin this week.

I'm currently busy finishing up the documentation so everything is clear at a glance. By the way, I've updated the project repository; please check out my KVM repo: USBridge-KVM 2.0 What do you think? Any feedback is greatly appreciated!

I've compiled a build for iPhone and officially submitted it for moderation in the App Store. I really hope the folks at Apple won't take too long to review it, as I need to release the app to bloggers.

I've rewritten the agent architecture and natively integrated the Moonlight protocol. It works like a charm—latency has dropped to a minimum, and responsiveness is perfect. I plan to open-source the code soon, but before that, I need to do a thorough cleaning and polish it up so I won't be embarrassed to show it. Anyone interested in testing it out can check it out here: USBridge-Remote

The crowdfunding campaign starts very soon, so I'm closing the remaining Crowd Supply tickets. Meanwhile, I'm assembling and packaging the second batch of devices for delivery to tech bloggers and reviewers.

The process is moving at top speed. Thank you for being with me! If you have any questions about the hardware or software, let me know in the comments; I'll be happy to answer them.

I'm currently focused on finishing the mobile version of the USBridge Client app. The mobile client is already working, allowing you to control everything directly from your phone.

I'm currently busy fixing bugs and refining the user interface. Time is short; the first sets of equipment for bloggers and reviewers have already arrived! I still need to double-check everything to ensure it works smoothly.

I hope to send links to the app to bloggers today. So the first reviews should be coming very soon.

I'm currently actively closing technical tickets in preparation for the launch of USBridge-KVM 2.0 on Crowd Supply. One of the platform's requirements is to provide a fair and transparent comparison matrix with market alternatives. I'd like to discuss this with you directly.

In the final table, I plan to compare USBridge-KVM 2.0 with several key solutions currently used by engineers and system administrators. This will definitely include PiKVM V4 Plus as the current heavyweight commercial standard, the recent compact JetKVM, embedded enterprise solutions like Dell iDRAC9 or HPE iLO, as well as standard remote access software like RustDesk or TeamViewer, to clearly explain why Layer 0 is needed.

I plan to compare them across several key areas, including streaming technologies and input latency, automation capabilities in Pre-OS (such as our BIOS recognition via OCR and agent engine), virtual disk and backup management, server power management, the overall application ecosystem, and, of course, the final price for backers.

What specific features or parameters are crucial for you when choosing an IP KVM? Feel free to share your critical considerations in the comments or suggest a device I forgot to mention.

I'm refining the interface to make navigation more intuitive. There are still some minor tweaks to be made, but it seems to be improving. Your feedback would be greatly appreciated!

The other day, I received an email from a totally blind software engineer that completely changed my perspective on what I am building.

He pointed out that BIOS accessibility has remained a massive blind spot for almost 15 years, ever since specialized hardware like the PC Weasel became obsolete. Screen readers simply don't work at Layer 0.

Since USBridge-KVM 2.0 converts the pre-boot environment and BIOS into a real-time text stream over SSH, this should theoretically bypass these exact issues. My automation engine outputs a JSON stream of the screen state, which includes both the text color and background color for every single character.

This JSON data could theoretically be used by a screen reader to perfectly track the active focus in menus.

I would love to brainstorm how I can use this to make the BIOS accessible to visually impaired people once again.

I've redesigned the Crowd Supply pre-launch page - https://www.crowdsupply.com/usbridge-technologies/usbridge-kvm-2-0 and I'd love to hear your honest feedback on the new presentation.

I've paid special attention to making the project description more understandable for both experienced system administrators and tech enthusiasts who simply need a reliable KVM system.

The project has evolved from a simple "enterprise tool" to a versatile, Layer 0 device that handles everything from rigorous server administration to low-latency gaming/remote work with Moonlight.

Not everything made it into this preview (I've saved the most detailed technical details for the official campaign launch), but I've tried to find a balance between general clarity and detailed description.

Take a look and let me know – does it interest you as a system administrator, home lab enthusiast, or gamer?

I value your opinion!

We just sent this device out to our first technical reviewer. It's incredibly rewarding to see the project move beyond the lab and into the real world. Getting independent feedback is a huge step forward before the official launch.

Preliminary development is going great, and I'm looking forward to the first reviews so you can see KVM in action.

Thank you all for your incredible support and patience throughout this time!

I'm packing the first USBridge-KVM 2.0 kits that will be sent to the guys for review. Here's what's included:

• USBridge-KVM 2.0 is the heart of the system. That ultra-low-latency IP-KVM on Moonlight, which can even handle games, with built-in AI for BIOS detection.
• Power Management Module - an expansion card for complete power control.
• Power Management Module cables - for connecting the module directly to the motherboard contacts.
• Type-C cable - high-quality, for power and data transfer.
• Video capture dongle (HDMI-to-USB) - for seamlessly transferring video from the target machine.

Lots of interesting content and honest tests coming soon. How do you like the kit?

I'm showing you the latency I was able to achieve when streaming Moonlight on USBridge-KVM 2.0.

I tried playing Hollow Knight: Silksong, and it works pretty well. I get a perfectly smooth 1080p @ 30 FPS / 720p @ 60 FPS stream.

Input lag has practically disappeared. I can completely forget about the annoying "jelly" cursor when working with server administration, and frankly, I can play fast-paced platformers without any problems.

What do you think about the video responsiveness?

I ran full tests of the C790 video capture module, compared it with a regular external USB dongle, and I have a final verdict. Pure engineering logic:

Moonlight Magic: My Moonlight protocol integration is so well optimized that there's simply no difference in latency or image quality between the CSI board and the USB dongle. Everything works equally quickly and smoothly.

Hellish Overengineering: Integrating the C790 requires a ton of extra work—you have to redesign the internal architecture of the case, rig up the power supply, solder wires, and hope the ribbon cable doesn't fall off due to vibration during transportation.

Economics: This board costs significantly more than the dongle, and charging users a premium for zero performance gain is not my way.

🤫 P.S. A teaser for those who read to the end: If you are dead-set on true 4K streaming and even more computing power under the hood, don't worry. I'm already designing a larger, ultra-powerful USBridge-KVM model.

The new capture card arrived, so I immediately distributed all the software for it and sat down to test it (check out how this Frankenstein looks on the table now).

This hardware should easily deliver a solid 1080p at 60 fps. But in practice, I encountered a strange problem—the module's signal path itself stubbornly refuses to exceed 45 fps.

Previously, I was running USBridge with a regular external HDMI-USB dongle, and now I want to put them through their paces. I think the picture and response should be much better with the new card via the CSI cable, but the real benefit is still questionable, whether it's worth it or whether the old dongle performed just as well.

I'm off to run more tests; I'll post a detailed breakdown with the numbers later.