Review: Luwu Dynamics XGO-Mini2

The XGO is a lap-size robot dog, marketed as “a metal pet on your desk,” but it's primarily sold as a learning tool for programmers with an interest in machine vision and robotic automation.

Robot pet fans should know, however, that this metallic mutt has more in common with Boston Dynamics' ominously-styled Spot than with Sony's consciously cute Aibo, with a remarkably well-made and solidly engineered metal body. In movement, its servos whirr and its plastic feet click satisfyingly across the floor.

Luwu Dynamics is clear that the XGO-Mini2 is more of a tool than a companion. Also, at $849, it is much more affordable and considerably more open to tinkering than Sony's $2,900 robot pet and more than $73,000 cheaper than Boston Dynamics’ robotic quadruped.

The XGO range, as it's sold, is fundamentally a robot body peripheral for a Raspberry Pi compute module. The robot's screen-equipped “head” module, the XGO-CM4, houses a Raspberry Pi CM4 with 2 gigabytes of RAM and an ESP32-based daughterboard that provides servo control for the body, an audio DAC and speaker, SD card slot, four buttons, and a camera.

There are also Micro HDMI and USB-C ports to connect to a display and input devices, plus two four-pin connectors for compatible components. The XGO-Mini2 supports the OAK-D-Lite computer vision module and LD06 LiDAR sensor.

I've been testing a preproduction version of XGO-Mini2, which means that my experience will differ from that of customers who receive the fully polished release version. Notably, the metal arm that allows XGO to pick up and put down objects was 3D-printed in metal for my review sample, the case with integrated screen for the compute unit was flimsier than the final design is expected to be, and elements of the software were still in active development during my testing, with accompanying documentation still in the process of being written.

Photograph: Luwu Dynamics

The XGO-Lite 2 I got my hands on is the lighter-weight of the robot's two versions. Its aluminum alloy body is a little less thick, and its servos are a little less powerful. The Lite version consequently has a longer battery life, providing an estimated two hours of use rather than the XGO-Mini2's quoted one hour.

The battery drains even while the robot isn't doing much, as it's powering the compute module. It'll run while plugged in, but you'll want to avoid asking it to move while it's trailing a power cable. If your XGO's just hanging out on your desk unplugged while you're programming it, it's easy to get distracted as its battery life runs away, but an hour or so of functional time feels generous when you actually put the robot down to have it run your commands. Although the Raspberry Pi hardware can handle standby and wake states, nothing of this sort is implemented by default.

The body can also be used with other single-board computers and microcontrollers, such as the Micro:bit and Pico:ed, thanks to modules produced by longtime XGO collaborator Elecfreaks. Pleasingly, owners of a first-generation XGO-Mini will be able to order an XGO-Mini2 upgrade kit for their existing hardware, including the arm, driver board, and computing hardware.

The most disconcerting thing about XGO is the choice to present it in its AI behavior demos as a cute robot puppy. Several of its interactive modes feature an unpleasantly cutesy puppy face. Have it run its “Show” demo, which demonstrates all its (impressive!) preprogrammed moves, and you'll be treated to a range of these performed to a song that informs us that “my puppy is a little baby dog.” It's not good, even if you like saccharine dog imagery.

This is deeply dissonant with the cyberpunk look and feel of the robot dog's metal body. Maker Luwu Dynamics wears its influences on its sleeve, and XGO looks more than a little like a scaled-down clone of Boston Dynamics' Spot—famous as, among other things, a dancing militarized police dog. Fortunately, if you're up for a bit of modding, almost everything about XGO's behavior can be changed.

When you power up XGO, its screen presents the Luwu Dynamics logo along with three options: Program, RC and Try Demo. You can navigate through these using the buttons built into the sides of the screen/compute module case.

These range from basic speech transcription and command keyword recognition in “Speech,” to form and color recognition, and machine vision demos involving face recognition and gesture commands. Others serve more as template code for those developing for the system.

“AgeSex” is another machine vision demo, and a rather reductive one at that: If it detects your face as male, it'll bark at you angrily. If it believes you're a woman, it'll make a happy noise. It uses OpenCV gender and age detection with Caffe gender models, with the end result being a guess at gender that mostly depends on how you have your hair styled. It'll also take a stab at age detection.

“Emotion” tries to react to facial expressions using the Keras emotional recognition model. It's a bit laggy and compromised by low camera quality, but it actually does the job. “Recog" allows you to store and check for known faces, which has fascinating potential when it comes to creating your own robot-pet-themed applications. “Pose” is a hand and body pose tracker—actually a depreciated part of Google's MediaPipe machine learning library. Again, it's a bit laggy on the CM4, but potentially useful if you wanted to program simple sign language support into an XGO project.

The low position of the head module and its camera on the dog's body make interacting with any of the head-tracking functions rather awkward, unfortunately. Like many small creatures, XGO's worldview is mostly made of feet if it's on the floor, or torsos if it's on your desk.

"Teach" mode lets you position the robot's limbs by hand and record each motion for later playback. “Grip” and “Ball” use computer vision to have XGO use its arm to pick up objects you show it (a favorite with kids).

Its “QRcode” demo is interesting. It'll try to load or display content based on a QR code you show it, making it a fun combination with a QR code creator. This actually gets used in the forthcoming “Network” utility to set XGO's Wi-Fi defaults to your own network.

It even has object recognition, powered by Yolo, but it's not very useful, as it gets distracted by any person holding an object, isn't great at multi-object scenes, and identified my joypad as a cell phone, my phone as a refrigerator, and a can of Orangina as a parking meter.

Photograph: Luwu Dynamics

You can fully control XGO yourself with the XGOBOT app. This is fun in the way remote-control robots always are, because you get a robot's-eye view from the camera, along with complete movement, directional, and positional control over the body and robot arm. It feels like you're manipulating an emergency services robot.

XGO's small stature means that it can't manage stairs, or even hop down a single step, although it survived a fall onto its back from 25 centimeters when it tried, and it easily traversed the tangle of cables that lives on my floor.

It's also not rated water- or dust-proof, so you probably shouldn't use it to investigate that mysterious hole under your house. It's pretty good at looking under furniture, though, despite being a bit tall to get into really small spaces, particularly with the arm mounted on its back.

You can even use that arm to pick things up, with a bit of trial and error. The app can also command XGO to perform preprogrammed gestures, mostly themed after popular dog tricks, and pose it using fine positioning controls.

XGO is eminently customizable. Its software is almost entirely written in Python, and it runs Raspberry Pi OS, a Linux distribution based on Debian. The machine vision tools it uses are also all open source. A pair of custom Python libraries, xgoedu and xgolib, provide functions that control the robot's servos, sensors, speaker, camera, and screen, and every single Python script in its demos is just sitting in home/pi/cm4-main/, ready to be adapted into whatever you need.

But you don't have to go digging into XGO's backend to start developing. For basic programming, there's a browser-based interface that lets you send your code directly to the XGO and instantly run it. You connect to this via the XGO-Blockly link on Luwu Dynamics' website. This then runs locally, in your browser, and prompts you to enter your XGO's IP address so that it can connect over your local network.

Photograph: Luwu Dynamics

XGO-Blockly is an implementation of the Edublocks fork of Google's Blockly, a beginner-friendly integrated development environment (IDE) with a graphical interface that lets you drag and drop programming functions from a menu into connected, sequential blocks. This is actually a frontend for some Python code, which you can see and edit manually at any point.

I had to use the XGO-Mini command blocks to control my XGO-Lite, as the latter weren't yet working when I tested it. In some cases I had to dispense with the blocks and just write the code myself, or add a few corrections to the generated code. However, these are expected teething problems.

While not all functions were fully implemented as blocks during my review, the XGO team have been extremely responsive to bug reports, fixing every bug I reported. At time of writing, Blockly support for core functions for the XGO-Mini2 is near-complete, and the team reports that a fully functional version of the IDE is ready for release.

While not as kid-friendly as Scratch, another block-based visual programming language that's popular in the education sector, Blockly benefits from being a frontend editor for Python, spitting out real, editable programs. While you'll benefit from some familiarity with basic programming concepts, it's very approachable for interested beginners, particularly in combination with the examples provided in the XGO docs.

XGO is built to appeal to software hackers, and this is sometimes the easiest way to add basic functionality to the robot. When I received the prototype, the recommended way of getting it onto your local network for remote control or programming was to change the SSID and password of your Wi-Fi network to match its preprogrammed settings.

It was easier to pop out the microSD card and edit /etc/wpa_supplicant/wpa_supplicant.conf to include my own Wi-Fi network details, and this could still be handy if you don't want to generate a QR code with your Wi-Fi details on it.

And you don't have to pop out the SD card every time you want to look at XGO's file system. If you connect the Micro HDMI port on the XGO-CM4 and plug in a USB-C hub (both are provided with the final retail models), you'll get a full Raspberry Pi OS GUI, and you'll be able to connect a keyboard and mouse to navigate it. You can also enable SSH to give yourself remote network access to the robot from your favorite terminal emulator or SFTP-compliant file browser.

All of this makes life easier if you want to start making wholesale changes to XGO's features, behavior, and expression. And if you make any mistakes, you can just reflash the XGO's operating system SD card, so failure is low-stakes.

And that's the coolest thing about XGO: As it's built on open source software, and it is easy to revert to its defaults, you can make more or less any changes you please. Don't like the dog motif? Change the audio and facial expression image files into a cat or a screen full of Matrix-inspired glitch text. Add more libraries, write your own functions in Python, and change XGO's default behaviors.

Everything's open and accessible, albeit a little patchily documented at this prerelease stage. Python's a very readable language, which makes it easy to pick up what the different different functions do. It’s also widely taught in schools and introductory coding classes, making this a useful toy for those keen to develop their programming abilities. If you wanted to buy XGO for a group or family, every person could have their own XGO microSD card.

As a virtual pet, XGO isn't very rewarding—it's a string of demos with less potential for an ongoing relationship than a Furby. It can be made aware of, and is able to react to, its surroundings. And you can have it record a series of motions to reproduce, but there's no database to remember your past interactions with XGO. If you want it to know who you are, you'll have to write your own software for that.

But that's what it's actually designed for: experimenting and developing with accessible and interesting pieces of hardware that also happen to look and feel cool. And the XGO is open enough to make it possible without having to worry too much about ongoing support for anything apart from the Blockly browser app.

Sure, this desktop dog is no Aibo, but if you're into hacking together software for interesting hardware platforms, you'll have great fun with your new programmable cyber-pooch companion.