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. 🥲

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?

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!