I’ve done quite a few KVM reviews in the past, and there’s a reason for that: All of the homelab and industrial IoT stuff I test needs some sort of physical access for setup, and even if I do have monitors with multiple inputs, USB video capture dongles, etc., it gets really old to have to constantly re-wire stuff, switch between keyboards, etc.

Additionally, most of the newfound range of cheap/compact KVMs that have popped up over the past two years still need an Ethernet connection, and it’s become ridiculously hard to have even semi-permanent test setups–I keep running out of both power and Ethernet ports, and that’s been the reason why I’ve been limping along on Wi-Fi based Pi Zero KVMs as well as one or two KVMs that, sadly, require proprietary apps.

So when I spotted the Radxa Linkr, I just had to try it. And that was even before I knew I could get it to work with an AI agent…

Disclaimer: Radxa supplied me with a Linkr free of charge, and this review follows my usual review policy.

In the box, you get the Radxa Linkr and a set of cables (pictured above in real life, and below in the Quick Start guide).

The hardware itself is pretty comprehensive, and packs quite a lot into the small 70 x 22 x 12 mm enclosure:

• Rockchip RV1106G3 SoC, with a 1.2GHz Arm Cortex-A7 CPU, a RISC-V co-processor, 1 TOPS NPU and a hardware video encoder.
• 256MB of integrated DDR3L memory.
• 16GB eMMC storage or a microSD card slot (I got the variant with internal storage) for firmware and virtual media.
• HDMI input up to 2560x1440 at 30Hz, with lower-resolution modes including 1920x1080 at 60Hz and custom EDID support.
• Dual-band 2.4GHz/5GHz Wi-Fi 6 using an AIC8800 module, with client and hotspot modes.
• A USB-C device port for keyboard and mouse emulation, power (5V/2A) and firmware flashing.
• A separate USB-C network port for a direct host connection or 10/100Mbps Ethernet through the supplied USB-C to RJ45 cable.
• One FN user button, a system status LED and an HDMI/video status LED.

The device itself is tiny, and the single FN button is used to identify it on the discovery page or (with newer firmware) to toggle the Wi-Fi hotspot with a double press. You can see the USB-C connectors on the back and side through the semi-transparent casing in the photo above.

A nice touch that you will appreciate if you manage many machines is that there are indicator lights that show when someone is remotely connected (the blue power LED will turn green) or there is a video input problem (signalled by a blinking video status LED).

Besides direct USB connectivity to your machine (which I honestly didn’t spend any time on), the Linkr supports both 2.4GHz and 5GHz Wi-Fi. However, it doesn’t seem to support my particular flavour of WPA3 (at least in current firmware versions), so I stuck to 2.4GHz/WPA2 for all of my testing, which is plenty fast enough.

That’s a decent tradeoff for me (I had zero latency issues, although I spend so much time in VDI and remote console setups that I don’t notice delays anymore) and, at least in one of my tests, was the only way I could connect to a machine in a remote corner of the house where 5GHz has very little reach–but it managed 60fps just fine.

The Linkr is quite flexible in terms of video capture. I’ve needed to hack in support for custom EDIDs in my old PiKVMs, so it’s nice to see that is baked in, and the built-in HDMI bridge goes from 1280x720@30/60Hz to 2560x1440@30Hz, with standard 1080p in the middle.

I also found it a nice touch that the Linkr includes a virtual sound card that it exposes via USB to the target system, although I have had zero use for audio in any of my tests…

The Linkr, like all devices, does warm up while in use, and its metal underside can be surprisingly warm to the touch–and yet, my IR thermometer didn’t see it get past 45°C even after hours of continuous use (disconnecting, of course, lets it idle cooler).

As you’ve probably divined from the Quick Start shot above, this is a pretty trivial web-based setup: go to linkr.now (with Chrome or Edge, because Apple still hasn’t figured out most of the modern device-related browser APIs), and you get an HTML app that will find the Linkr and help you connect to it – via USB or, later, via Wi-Fi.

The entire thing is very slick, and the user interface is both responsive and easy to navigate–here’s a little slideshow of the original firmware version:

Firmware updates and release notes are available on GitHub, and since I got mine (v1.4.2), Radxa has added quite a few new features, as well as a bunch of fixes, in what is today v1.5.2:

• A Plugin Center, which is a sensible way to keep adding more features without changing the core firmware–I haven’t yet had time to investigate how I could build my own, since I only noticed it as I finished this draft.
• ZeroTier and EasyTier support (I use Tailscale myself, but it’s nice to see options).
• Screenshot OCR to recognise text in screenshots and edit or copy the results (see below); recognition runs locally, and an optional plugin supplies the OCR resources without Internet access.
• Experimental IPv6 support (which works, at least on my LAN).
• FN-button hotspot toggle (double-press it to turn the Wi-Fi hotspot on or off).

One fix in particular was very useful already (they fixed resolution switching with the Radxa Dragon Q8B as video input, and I’m still testing that this weekend), and the pace at which they are currently shipping updates is reassuring, even though I couldn’t find published source code for the firmware in the public repository.

Other than that, you get all the typical remote KVM features (as well as Tailscale support, which I use extensively):

• Video resolution settings (and custom EDID, as pointed out above).
• Wake-on-LAN (for any MAC address, although you can pin the ones you need).
• Keyboard and mouse control (as well as the virtual USB audio capture, all exposed via USB ID 1d6b:0104 - Multifunction Composite Gadget).

Mouse control can be set to both absolute and relative, as well as reversing the scroll wheel (which I thought was a very nice touch).

However, Mac and iOS users can’t really use some of the more advanced web UI features like screenshots, recordings or screen OCR, because they’re not available in Safari. Some of this is Apple’s problem, but I’ve hacked Safari-compatible screenshot support into other KVMs, so Radxa can probably improve that.

I did find the screenshot OCR feature interesting, but it requires pretty crisp text, and some SBCs just aren’t willing to play ball on their boot consoles–however, it can be immediately useful in a pinch:

A nice touch about this is that recognition happens fully in-browser:

• It uses tesseract.js to recognise English and Simplified Chinese.
• By default, it downloads OCR resources over the Internet, including the worker script from cdn.jsdelivr.net.
• The screenshot is processed locally by the browser worker, which returns the recognised text and bounding boxes to the UI.

The offline plugin just caches a local copy of the worker, engine and language data inside the Linkr itself, removing the external-download requirement.

But the real reason I am very much enjoying using the Linkr is that, unlike most KVMs, it actually exposes an API that you can either script against or just point your AI agent to.

I have been using that for over a month now to great effect (including doing a couple of Fedora and Windows installs, which is a veritable quagmire of edge cases) and built a piclaw add-on you can use as a reference.

The release notes also describe new API controls for resolution and video quality, which my add-on doesn’t cover yet. But the basic screenshot and input controls work amazingly well if you pair them with a vision-enabled model, and are really simple:

The documented public API uses an access token in the Authorization: token <token> header, and boils down to two endpoints:

• GET /api/public/snapshot returns the current screen as a JPEG.
• POST /api/public/control accepts an ordered events array containing keyboard, mouse, text and delay operations.

The control primitives are small enough to wrap directly in agent tools:

• keyboard presses or releases keys using browser KeyboardEvent.code names, so combinations are sequences of key-down and key-up events.
• mouse_abs positions the pointer using normalised coordinates between 0 and 1 (this can be a little tricky for some models, but they get it eventually).
• mouse_rel moves it by pixel offsets (both support mouse buttons and scrolling).
• text types up to 1024 characters, limited to printable ASCII, tabs and newlines.
• delay pauses between events for a specified number of milliseconds (useful when the target needs time to react).

That gives an agent the usual screenshot/action loop without installing anything on the target machine.

I had to burn through quite a few tokens in initial testing (and the skills my add-on bundles are the result of that), but you should be able to use a relatively cheap model to automate typical system administration tasks, as long as it supports vision.

Can it do fully unattended installations? Well… It’s tricky. Can you figure out when to enter the BIOS on a random machine and what key to press? That is so variable across machines (and sometimes even on the same machine) that the only way I got it to work was to get into the BIOS (after a few tries), pick the boot volume myself and then hand over to piclaw.

The results and reliability are highly dependent on the AI model you use. I’ve had good experiences with astra, opus or sol on a variety of desktop automation tasks, and they were all able to use the Linkr to go through a standard OS installer. I also got them to check Windows updates (clicking through all the steps and choosing when to reboot) and even do console rpm-ostree and flatpak updates (and reboots) without any issues except the high token count that comes with handling screenshots (and model-side OCR).

This is what currently makes the Linkr worth looking at if you want to automate hardware setup, with the caveat that it can, indeed, do away with the odd bit of drudgery, but you need to be smart about how to do it (only retrieving screenshots at intervals/decision points to save tokens, for instance) and, preferably, script things so that the model is only really phoning it in.

For me it was almost a straight conversion of some of the stuff I’ve actually been doing in Proxmox for a while, so it’s nice to have a way to set up a blank box.

Hardware-wise, I should note that you can’t hit a reset button with the Linkr, so if your hardware doesn’t honour Ctrl+Alt+Del, you’re stuck. Other KVMs have dedicated interfaces to do that (and you can always use a smart plug, like I do with my test SBCs), but it’s something to keep in mind.

Additionally, I’ve had a couple of instances where the Linkr had a little trouble fitting directly into PCs or SBCs (including Radxa’s own) because of lack of clearance around the HDMI port or having the USB-C port on the side (which in a few cases meant it would point straight into the desk).

Nothing that you can’t fix with an HDMI extension cable (I used a Chromecast male-to-female extension, which is around 10cm), but worth mentioning since it doesn’t come in the box.

Another minor hassle is that if you power the Linkr directly from your target device, many devices (even standard PCs) won’t power up USB until they’ve gone past display initialisation, so the Linkr may skip UEFI/BIOS screens while it boots.

When testing SBCs, I had to use that power/data splitter cable to keep the Linkr powered up independently–otherwise it would boot up after the servers had tried (and failed) to initialise HDMI, so I’d get no video out (and, depending on device, they wouldn’t reactivate HDMI after USB input or Wake-on-LAN, either).

I’m obviously biased towards anything that lets me put a machine on Wi-Fi and get at it through a browser without installing yet another proprietary app, so the Linkr already had quite a bit going for it.

But having an API that I can script against, or hand over to an agent once I’ve persuaded the machine to boot from the right device, makes it considerably more useful for the sort of testing I do, and I am quite likely to replace some of my other KVMs with Linkrs solely to free up Ethernet ports.

I’ll still need the odd HDMI extension and a separate power supply for a few machines (especially ARM ones), but at least the wiring will be much easier, and who knows, I might even start testing more than one SBC at once…

Regular readers will know I’ve had a long fascination for the Yamaha DX7–after all, besides getting a Reface DX quite some time ago, I also built a MiniDexed box and accumulated more software instruments than I have time to use, as well as an embarrassing amount of other physical gear that brands me as a victim of Gear Acquisition Syndrome.

I can only manage to dabble in music occasionally, but I’ve been interested in FM synthesis since the heady days of the 80s, so the M-VAVE FM-1 was like catnip to me because it was billed as a pocketable DX7: six operators, a little keyboard and a speaker packed into a battery-powered box, with both USB and Bluetooth MIDI.

Disclaimer: M-VAVE provided me with an FM-1 review unit free of charge, and as usual this article follows my review policy.

But you just know a synth is becoming a cultural phenomenon when it floods all your feeds–including your GitHub watch list. Like the Xteink X4, the FM-1 has become a hackers’ paradise–but unlike it, it has blossomed into a music platform with literally dozens of open source firmware alternatives (some of which have online emulators).

And that is a completely different thing indeed, possibly with profound implications for conventional synth manufacturers. And if you’re in the synth scene, well… Just this week, it starred on a Bad Gear episode.

Update, a week later: M-VAVE seems to be leaning into this heavliy and has just published an open firmware workbench and a bunch of additional resources, which kind of validates my points below and is amazing to see.

From what I’ve been seeing (and I’ve compiled quite an extensive list of resources so far), the popularity of the FM-1 is due to a pretty straightforward combination of factors:

• It is quite cheap (less than $70 depending on where you live)
• It has a unique combination of size, hardware features (a nice screen, battery, USB audio, Bluetooth and TRS MIDI) and various knob controls
• It is very hackable

Say what you want about the keyboard (which is a little inconsistent and likely not very long-lasting), we are talking about $70 for a device that can do both audio and Bluetooth MIDI and have a usable compact screen, features that stupefyingly expensive high-end gear has effectively never shipped together (well, statistically).

The specs are reasonably straightforward, so we’ll go through them right away:

• 161.5 × 96.5 × 28.6mm, approximately 250g.
• 27 silicone keys, colour TFT
• USB-C MIDI, BLE MIDI, 3.5mm MIDI IN
• 3.5mm audio jack and a tiny built-in speaker on the underside
• 2000mAh battery (~12 hours play time)

It also comes in a range of colours–I picked the black-and-green version because it reminded me of the original DX7, and I don’t regret my lack of imagination one bit despite it not really being a rational choice–but it was an easy one.

When I decided to get the Reface DX many years ago, I wanted something I could mess about with without a DAW or computer. I liked its speakers and keyboard, but wished it had better connectivity and the DX7’s six operators rather than four, and effects were practically non-existent.

Well, the FM-1 has six sine-wave operators, 32 algorithms and 12-voice polyphony, accepts DX7 SysEx banks directly, and adds six effects (filtering, chorus, phaser, distortion, delay and reverb), an arpeggiator with half a dozen different modes and a sequencer, which are described succinctly (but adequately) in the little handbook it ships with.

By pocket synth standards this already is a veritable cornucopia, but more to the point, the default firmware packs in sane operator editing (well, much saner than the DX7, which was effectively a brick wall, and nicer than my Reface DX).

Here, patch editing is much easier: the display shows the algorithm, and you get a series of keyboard shortcuts for selecting operators and other parameters that can be directly tuned via the knobs.

And patch compatibility is surprisingly decent. Most people I’ve seen reviewing it seem to stick to the factory stock sounds (which are similar to some originals, but often with the FM-1 effects turned up to 11), but I loaded up the DX7 US factory ROM, which has most of the trademark sounds people associate with the DX7 (largely because most musicians couldn’t really figure out how to edit patches).

I compared it to my MiniDexed build and Dexed, and although there were a few differences in timbre, most sounds were very, very close.

And that’s where you start understanding how easy this thing is to tweak–all you need to have is a browser that supports WebMidi (which, of course, Apple still refuses to support in Safari), pop over to something like fm1-editor.com, and it will merrily send SysEx commands to your FM-1:

This is flabbergasting, because it is a far cry from, say, building a MiniDexed – that might be a bit more powerful, sure, but only in the sense that I can theoretically run eight parallel DX7 engines in it. And yes, this editor almost works with it (mine needs a software upgrade). And of course we’ve been able to do the same on various iPad apps, but it doesn’t feel the same.

Audio quality was… OK, I guess. I used mine mostly through my aggressively non-audiophile Logitech desktop speakers and random headphones, and of course the USB audio is purely digital.

Even if you don’t want to edit anything, the little colour TFT and clever control mapping make it really easy to navigate presets (you get 128 of them, by the way), and about as easy to edit presets as, well, any FM synth would be–again, much better than the Reface DX, although most people will just get Dexed and edit them that way.

If you stick to the stock firmware, that is.

I initially thought this to be based on a more modern microcontroller, but as it turns out the FM-1 is based on the JieLi AC791N/WL82, which I had never heard of before but seems to be a SoC that includes a fairly popular pi32v2 microcontroller associated with the Blackfin family.

The Jieli AC791N toolchain seems to be very well documented, but of course there’s already an entire reverse-engineering repository for the stock firmware, which includes the OTA protocol and a bunch of additional info.

And yes, a lot of the analysis and firmwares rely on AI, but having a relatively open toolchain available and decently clean references (plus plenty of code being shared between different firmwares) has definitely lowered the barrier to entry, both in terms of reducing the work of building new variants and integrating things from other existing instruments–there are emerging ports of other “classic” open-source synths in the works, and of course someone already has it running Doom…

But that’s not relevant to regular people. What is relevant is that WebMidi SysEx patch transfer was just the tip of the iceberg: the entire firmware image can be transferred that way, which makes it trivial for anyone to distribute (and use) different firmware versions–so to join the fun, all you need is an FM-1, a USB-C cable and a browser.

I think the best way to understand how popular and diverse this thing is is to dive into Reddit, where you’ll find there are already enough firmware variants for people to be ranking them in multi-page Google Sheets:

If that’s not your thing, there are also quite a few marquee sites popping up all over the place, like this one, which provide you with the ability to instantly download and install a bunch of popular firmware variants:

I decided to go with Sloop, because it has a certain feel about it–in short, it reminds me a lot of how I expected the OP-1 to be like, and it feels like it was influenced by it to some degree (there are quite a few whimsical visualizations in there), besides having an absolutely kickass sequencer and web editor; this is becoming a staple feature in most custom firmwares, but I liked this one and am sticking with it:

But the genius part of Sloop (and a few of the other firmwares I’ve tried) is how they make use of the hardware: You typically push and hold to switch into a different mode, and knobs, buttons and keys change functionality: the same controls can edit operators, trigger drums or operate a sequencer.

As someone who owns a Roland Aira S-1 (that I don’t think I ever wrote about), the core workflow and mode switching is familiar–but the screen makes one heck of a difference, since the S-1 has a puny LED segment display and no way to visualise anything:

In short, the experience of the FM-1, even with stock firmware, is better than the Roland. But with custom firmware, the gap is tremendous. One FM-1 can, at least theoretically, do everything the entire Roland Aira range does, in one box.

The effects are decent enough that you also don’t need pedals (or a Norns like I built a few years ago), or string together a bunch of boxes. Plug in a MIDI controller (or a companion synth like the ESI Xsynth, which is a great match), and you’re set.

The way I see it (and even though M-VAVE certainly wasn’t planning this), the FM-1 might well become a cult device, because in complete contrast to just about everything else in the same form factor–Volcas, Behringer’s zillion clones, etc., it has effectively become a platform.

I can’t wait to see what people like David Hilowitz might make of it (if he ever decides to do his own take on firmware, of course).

This was a bit of a mixed bag, but mostly because of my expectations towards Bluetooth MIDI. BLE has always been very high on my list of “must have” features because it’s a pain to deal with wires when you’re trying to juggle an iPad and other gear on a couch, and I am happy to report that the stock firmware works with BLE and my iPad.

However, very few of the custom firmwares do, partly because they’re GPL 3 and partly because Bluetooth support relies on a rather bulky proprietary firmware blob that takes up a fair amount of resources on the FM-1, so all Felucca-based variants (like Sloop) omit it, which is sad to say the least.

But all firmwares support USB audio and MIDI, and those just work with AUM, so at least I only need the one cable (even if the iPad is, as usual, confused as to how to use an extra audio interface, a situation which has only slightly improved with iOS 27).

I haven’t tried plugging both the FM-1 and the Xsynth to my iPad yet (solely because of lack of time), but I can’t see why it wouldn’t work, and will update this post when I do.

I love this thing, and will be looking out for the SMK-37 Elite because the Pro variant seems to run on a similar platform and it might be just a matter of time until people figure out how to port FM-1 firmware to it. There’s no guarantee at this point, and the price point is quite likely to be much higher, but one can hope…

Regardless, I think that M-VAVE should lean into the homebrew firmware momentum and make some of this firmware bonanza official–the traditional synth industry very much enjoys churning out not just endless variations on the same theme, but also tiny portable devices that do much less and are much harder to use, and this is clearly an opportunity.

After all, even if I wanted an unapologetic clone of a classic synth like the Behringer JT Mini, why would I spend the same for something that will never be as customisable or configurable?

Again, as someone who owns a Roland Aira S-1 and is constantly disappointed by the utterly stupid menus and clunky interface that is being sold for roughly three times the cost of an FM-1, I hope people take notice not just of how much value you can deliver at the price point (the hardware combo is very nice, even if you just use stock firmware), but also how much better the custom firmware experience is when compared to “normal” instruments.

For quite a few years now, there has never been a good reason why digital synths needed to be single-purpose devices, and this is a very decent proof point.

If you have a significant other in your life that likes synths and sequencers, get them one for Xmas. Period.

A few months ago, around the time Googlebooks were announced, I became really interested in Chromebooks again, partly because I’d completely lost touch and partly because I heard good things about the new ARM chipsets, namely the MediaTek Kompanio Ultra. But Chromebooks are not a common thing in my neck of the woods.

Read More...

Still very much in line with the overall return to work mood of the past few weeks, I thought I’d post some notes about work gear. You see, I have been using a “Surface Laptop for Business 13in 1st Ed with Snapdragon” (I kid you not, that is what it is called) for a couple of months now.

Read More...

Following up on my testing of the LattePanda Mu and IOTA, this time I’m looking at the Sigma, which (as is becoming the norm with my recent pieces) I actually got before summer break.

Read More...