The Smart Mirror turns a mirror into a style consultant. With a tap on Scan your look, a USB camera frames the garment being worn and the system recognises its colour and type, then suggests how to complete the outfit. The example runs on the Arduino VENTUNO Q board and shows how local visual AI can become part of a context-aware retail experience. Here the inference happens on the board, not on a remote server: images never leave the device, so privacy and latency stay under control.
The flow is linear and reads well from start to finish. A USB camera provides a live video stream, and the most recent frame is saved into a shared buffer. When Scan your look is tapped, the last frame is analysed locally on the VENTUNO Q board by the Qwen3-VL model, accessible through the Arduino VLM Brick. The model identifies the main garment and its colour and returns two short sentences: a description of the outfit and a style suggestion.
Two App Lab Bricks and an MJPEG stream to the browser
The result is sent to the browser and shown over the live camera view. The browser displays the live feed through an MJPEG stream exposed by the backend. The application therefore uses two App Lab Bricks: the Vision Language Model Brick and the Web Interface Brick. The first handles frame analysis, the second the page and the stream. The prompt behaviour can also be customised through a single configuration file, prompt.py.
Arduino VENTUNO Q as the compute board
USB camera for the live video stream
Arduino VLM Brick to access the model
Vision Language Model Brick for frame analysis
Web Interface Brick for the page and MJPEG stream
prompt.py to customise the prompt
Anyone who wants to rebuild the project will find the parts list here is fairly short overall. The VENTUNO Q board is the heart of the system, while the USB camera is the only sensor required. The Qwen3-VL model does not need training: it is used as it is, through the Arduino VLM Brick.
The physical assembly is not described in the example: the system relies on a USB camera connected to the VENTUNO Q board and on a backend that exposes the MJPEG stream. The rest, from the framing to the physical mirror, depends on how you want to build the mount. The software side, on the other hand, is all inside the two Bricks and the prompt.py file.
What changes with visual AI inference running locally
The interesting point is not the individual style suggestion, but where it is computed. The Qwen3-VL model runs on the VENTUNO Q board, so no image of the garment being worn is sent to a cloud service. As a result, latency stays low and privacy is simpler to guarantee: what the camera sees does not leave the mirror. The system also works without an internet connection, because inference is local.
The complete flow can be summed up like this: the camera produces the frames, the shared buffer holds the most recent one, the model analyses it on request and the browser shows the result over the live video. Every step stays on the board or on the local network, and the tap on Scan your look is the only trigger for the analysis. If you want to see how the project is built and which files it uses, the post on the Arduino blog is the place to start.
For those working in retail or in the maker world, this Smart Mirror is a concrete example of how local visual AI can power a complete, real-time user experience. No cloud is needed, no fast connection is needed, no images travelling outside the home are needed. A USB camera, a VENTUNO Q board and two well-chosen Bricks are enough.
JBR-001 is an open source desktop robot that sees and recognizes the objects in front of it, then reacts with movements, sounds and animations. It was created by syntheticAIdata and built around the Arduino UNO Q 2GB. Inside there are three servos, a camera, a distance sensor, a buzzer and an animated display. So it is not yet another blinking ornament: it is a platform for experimenting with robotics, computer vision and edge AI on a workbench.
Assembly starts from a body of 3D-printable parts that house the board and the rest of the electronics. The head contains the camera, mounted so that it looks straight ahead of the robot. On the back of the same head sits a Modulino Distance, which continuously measures the distance to nearby objects. The arms and the rotation of the head, on the other hand, come from three servos. The mechanics are therefore easy to replicate for anyone who already has a 3D printer at home.
Overview of the hardware project
Servo pins and distance thresholds in the code
The three servos split the tasks: one rotates the head, the other two control the arms. In the code the pins are HEAD_SERVO_PIN = 9, LEFT_ARM_SERVO_PIN = 10 and RIGHT_ARM_SERVO_PIN = 11. The rest positions are all at 90 degrees, so HEAD_CENTER = 90, LEFT_ARM_CENTER = 90 and RIGHT_ARM_CENTER = 90. The servos also use a separate external power supply instead of drawing power from the UNO Q: a forced choice when three motors start at the same time.
The distance sensor decides when the robot should notice someone. In the code the detection threshold is DETECTION_DISTANCE = 200.0, while the reset one is RESET_DISTANCE = 250.0. The units are not specified in the project material, so they should be checked on the bench before trusting them. The margin between the two thresholds prevents the robot from switching on and off continuously when someone stays right on the boundary.
Heartbeat on the display, a greeting in notes and the vision model
The robot’s responses go through three different channels. The LED matrix display is driven with bitmaps of 8 rows by 13 columns, the two used for the small and large heart. In the heartbeat animation the delays are 120, 100, 160 and 700 milliseconds, and the last long gap gives the sense of the pause between one beat and the next. The sound greeting playHello instead uses the notes 523 Hz (C5), 659 Hz (E5), 784 Hz (G5) and 1047 Hz (C6), that is a C major arpeggio rising by one octave.
The most interesting part comes from the camera mounted in the head. It connects through a USB-C hub and gives the robot a front view of its surroundings. The captured images can be processed on the UNO Q with a trained computer vision model: this way JBR-001 does not just understand that something is nearby, but identifies the object and uses the result to decide how to react. Consequently the same hardware can turn its head, move its arms, change the image on the display or play a short sequence.
Arduino UNO Q 2GB as the robot’s brain
Modulino Distance for continuous distance measurement
Modulino Motors for motion control
Modulino Buzzer for sound sequences
Arduino USB-C Hub (8 in 1) to connect the camera
Three servos for head and arms
Camera mounted in the head
3D printer for the body parts
On the software side you need Arduino App Lab and the JBR-001 source code, plus a trained computer vision model for object recognition. The project has 1805 views and 2 respects. Anyone who wants to rebuild it starts here: the maker syntheticAIdata’s site, where the code and the instructions to replicate the build are. For the servos, an RC servo control module simplifies the wiring when the channels to drive grow. The project’s distance sensor is a Modulino, and as an alternative you can consider a ToF laser sensor for close-range measurement. The board everything runs on is the 2GB version, while the catalogue also lists the Arduino UNO Q 4GB in a complete kit: same family, more memory for vision models.
The single-board computing market is shifting rapidly, and we are moving into an era of unprecedented possibilities where edge AI, computer vision, real-time control, and rich sensor streams converge locally. Yes, it’s exciting – but even amidst this “explosion” of hardware, an age-old rule holds true: define what you want to build before picking your tool.
No single board can (nor should!) excel at everything. A low-power embedded sensor, an autonomous robot, and a high-throughput video server all demand different architectures. For example, if you are weighing hardware choices for a general-purpose Linux setup versus a hybrid microcontroller, read this in-depth review to evaluate how different design philosophies match your requirements.
In concrete terms, it’s great to get a sense of what each board can do – and even better if you can look at a variety of cool projects at the same time! So here is a selection of what we are seeing developers build across key domains with the Arduino® UNO Q board, leveraging its dual-brain to bridge high-level AI workloads with deterministic physical control.
Dive into perception-driven robotics
Robotics excels on hybrid platforms because physical movement requires tight, real-time microcontroller timing while visual recognition requires heavy AI processing.
A robot arm that sees you: Uses camera vision designed to recognize people and a robotic arm built to deliver items, with a Modulino LED Matrix providing visual feedback.
UNO Q Braccio: Integrates Edge Impulse AI and ROS 2 in a platform engineered to support robotic arm control, including simulation in Gazebo.
Face-following robot: Uses Edge Impulse computer vision designed to track faces and convert tracking data into physical servo movements.
AI agent robot: Uses a local AI agent built to support physical navigation and decision-making tasks in real-world environments.
Explore the world through computer vision and spatial sensing
Instead of just streaming video, local machine learning turns cameras and sensors into environmental perception engines.
Gesture-controlled input system: Uses a standard webcam and Edge Impulse in a workflow built to convert hand gestures into inputs for digital applications.
Real-time LiDAR room mapper: Pairs LiDAR sensors with Edge Impulse ML in a system engineered to help interpret spatial data and interpret room layouts locally.
Create smart environments with interactive AI
Local AI allows devices to run full “sense, interpret, decide, act” loops without relying on cloud latency or external servers.
Talk to your house: An all-in-one smart home hub engineered to support wake-word detection, voice commands, sensor management, and a web interface.
Clawrophyll: A smart houseplant system designed to run a local AI agent directly on the board.
We don’t need every platform to do the same thing
The technological landscape is expanding, giving us more tools to build with: the goal was never to find one ultimate board “to rule them all”, but to match your project’s unique demands to the right architecture. Whether you need a raw Linux computing hub or a dual-brain setup like UNO Q, starting with a clear target can help you build smarter, faster, and more effectively. Today, we have more options, more possibilities – and this may ultimately be the most exciting part in the current era of single-board computing.
Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
UNO Q was designed around a dual-brain architecture that is built to bring high-performance computing and real-time hardware control together on a single board. The Linux environment on the MPU side is constructed to let developers install and run familiar open-source software – the same tools they’d reach for on a server or any popular SBC. Meanwhile, the STM32H5 microcontroller runs a dedicated Arduino Core on Zephyr RTOS, handling sensors, actuators, and time-critical I/O with deterministic precision. Together, they make the UNO Q something more than the sum of its parts.
What follows is a set of concrete examples: real software platforms you can install on UNO Q today, what each one enables, and why having the microcontroller in the same system changes what’s possible.
#1 Agentic AI development
UNO Q is engineered to put an AI coding agent inside the hardware it is writing for. An agent running on the board can receive a goal, process context, call tools, interact with services, and – through the board’s hardware interfaces – turn decisions into real-world actions. The reasoning comes from a frontier model over the API, but the tool calls run on the device. That last part is what makes this different from running an agent on a laptop or a server: the machine executing the decisions is also wired into the physical world.
The practical starting point is installing an AI coding agent, such as OpenCode, directly on the board. With the right context added – for example, knowledge of the Arduino® App Lab CLI and the board’s specific capabilities – it can set up Linux services for you, answer questions about Debian on UNO Q, and build physically connected Arduino apps end to end: create the app, write the sketch, deploy it, read the output, iterate. Any agent can write a sketch; only one running on the board can deploy it and see what happened.
More broadly, this creates a meaningful bridge between generative AI and embedded systems. Only the reasoning leaves the board: the sensors, actuators, and data stay where they are.
Home Assistant aims to turn UNO Q into the center of a local smart home or building automation system, connecting lights, climate controls, energy meters, and other compatible devices through a single dashboard and automation engine. Running entirely on the Linux side, it is built to handle scheduling, historical data, dashboards, and integrations – with no cloud subscription required.
The real advantage emerges when custom hardware enters the picture. A Qwiic temperature and air-quality sensor connected to the board’s Qwiic port could feed live data into Home Assistant, while an Arduino sketch running on the STM32H5 microcontroller is constructed to drive a ventilation fan through a relay based on those readings. Home Assistant is designed to manage the logic and interface on Linux; the microcontroller is engineered to handle the physical layer. The two communicate via the onboard RPC bridge, with no external Arduino board required.
n8n is a visual workflow automation platform that is built to connect services, APIs, databases, and devices – think of it as a self-hosted alternative to Zapier or Make, with full data sovereignty because everything runs locally.
Running n8n on UNO Q is designed to bring those workflows to the edge. A single workflow could receive sensor data from the microcontroller side, process and store it in a local database, update a dashboard, send a notification to an external service, and trigger a physical output – all in sequence, all on the same device.
The combination makes UNO Q a practically designed platform for rapid prototyping, industrial automation, smart building control, and local edge orchestration where cloud latency or dependency would be a problem.
#4 Pi-hole network shield
Pi-hole is a DNS-level filtering service that is structured to block advertising, tracking domains, and unwanted traffic for every device on the local network that uses it as a DNS server. On a standard single-board computer, that’s where the story ends.
UNO Q is different: the Linux side runs Pi-hole and its web dashboard, while the microcontroller can drive a dedicated status display, visualize blocked-request activity in real time, trigger an alert if the DNS service becomes unavailable, or provide a physical button to temporarily pause filtering – without opening a browser interface.
It’s a small example of a broader pattern: UNO Q aims to turn passive software services into systems with physical feedback and control.
Frigate is a network video recorder built around real-time object detection. It can process camera streams locally to identify people, vehicles, animals, or other defined events – and running it on UNO Q keeps that processing at the edge, where it belongs.
UNO Q is a practical host for Frigate for a few reasons. Cameras can be connected directly via USB or accessed remotely over RTSP (Real Time Streaming Protocol) when Frigate detects a relevant event, the microcontroller side can respond immediately – triggering a light, an alarm, a relay, or a Modulino-based indicator – without any additional hardware.
Sensitive footage stays local. Response times improve. And the physical response doesn’t require a round trip to the cloud.
#6 Local NAS with SMB
UNO Q can be configured as a lightweight network-attached storage server using SMB, making shared folders accessible to other computers and devices on the local network – useful for camera recordings, machine-learning datasets, sensor logs, or shared project files.
Paired with a dongle that gives cabled Ethernet connectivity and an external USB Disk, this can be a quick and instant NAS, flexible enough for sharing office documents with your colleagues or family.
A platform, not just a single application
Each of these applications is useful independently. The more interesting territory is what opens up when they run together.
Here’s one example of how that could look in practice: Frigate detects a person entering a monitored area and publishes the event via MQTT. Home Assistant picks up that event and switches on a light. n8n extends the response by calling an external API, logging the event to a database, and sending a notification. Meanwhile, the raw footage remains accessible over the local network through the Samba share. The microcontroller drives an indicator throughout. All of this runs on one board.
UNO Q is designed to provide a common foundation where Linux applications, local AI workloads, network services, and real-time embedded hardware control can be part of the same coherent system – rather than spread across multiple devices with their own power supplies, enclosures, and points of failure.
UNO Q is available on the Arduino Store or can be ordered from DigiKey, Farnell, Mouser, Newark, RS Components, Robu.in, and many other authorized distributors and resellers.
Arduino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
A new open-source project demonstrates how to combine computer vision and robotics on a single board. The robot, about the size of a desk, detects a human face through locally executed machine learning and turns toward it in real time, working at roughly 10–15 frames per second. Everything runs on the new Arduino UNO Q, without relying on the cloud.
Dual-processor architecture
The operation leverages the hybrid architecture of the UNO Q, which integrates two distinct units. The Qualcomm MPU microprocessor, running Linux, executes the AI model and the control logic written in Python. The STM32 MCU microcontroller, running Zephyr RTOS, drives the PWM signal of the servomotors with real-time precision.
The two processors communicate via Bridge RPC, a protocol based on MessagePack over an internal serial link, with a round-trip latency of about 8 milliseconds. This way, heavy inference stays separate from the real-time path, keeping motor control deterministic.
Vision, control, and web interface
The face-following robot built on the Arduino UNO Q.
A USB webcam captures video, while a lightweight face-detection model locates the face in the frame. A proportional controller then converts the horizontal position of the face into differential commands for the wheels. The project uses two ready-made App Lab “bricks”: one for camera-based object detection, the other for the web interface.
In particular, the browser-accessible dashboard lets you monitor detections and adjust steering parameters in real time, without recompiling the code. Every change to the sliders takes effect immediately via Socket.IO, making the tuning phase quick.
Technical details and motion safety
The robot uses differential drive with two continuous-rotation servos: a 1500-microsecond pulse corresponds to stop, while lower or higher values determine rotation in either direction. Additionally, the system limits Bridge calls to a maximum of 20 Hz, because sending commands too quickly would block the serial link.
The project therefore includes several protections: a “coasting” mechanism that maintains the last known position when the face disappears for a moment, a watchdog that stops the robot if detections are interrupted, and an emergency stop that ignores rate limiting to halt the motors immediately. Classified as an intermediate-level project, it is fully documented and released under an open-source license.
Ever since he was a young boy, [Tyler] has played the silver ball. And like us, he’s had a lifelong fascination with the intricate electromechanical beasts that surround them. In his recently-completed senior year of college, [Tyler] assembled a mechatronics dream team of [Kevin, Cody, and Omar] to help turn those visions into self-playing pinball reality.
You can indeed play the machine manually, and the Arduino Mega will keep track of your score just like a regular cabinet. If you need to scratch an itch, ignore a phone call, or just plain want to watch a pinball machine play itself, it can switch back and forth on the fly. The USB camera mounted over the playfield tracks the ball as it speeds around. Whenever it enters the flipper vectors, the appropriate flipper will engage automatically to bat the ball away.
Our favorite part of this build (aside from the fact that it can play itself) is the pachinko multi-ball feature that manages to squeeze in a second game and a second level. This project is wide open, and even if you’re not interested in replicating it, [Tyler] sprinkled a ton of good info and links to more throughout the build logs. Take a tour after the break while we have it set on free play.
Computer vision has traditionally relied on an assortment of rather involved components. On the other hand, everything you need to do this complicated task is readily available on an Android phone. The clever setup seen in the video here uses a smartphone to capture and process images, then send out a signal over Bluetooth to tell which way the device needs to be adjusted in order to focus on a nearby face.
An HC-05 Bluetooth module receives this signal and passes it to two servo motors via an Arduino Nano, moving the phone left/right and up/down.
Video resolution is always on the rise. The days of 640×480 video have given way to 720, 1080, and even 4K resolutions. There’s no end in sight. However, you need a lot of horsepower to process that many pixels. What if you have a small robot powered by a microcontroller (perhaps an Arduino) and you want it to have vision? You can’t realistically process HD video, or even low-grade video with a small processor. CORTEX systems has an open source solution: a 7 pixel camera with an I2C interface.
The files for SNAIL Vision include a bill of materials and the PCB layout. There’s software for the Vishay sensors used and provisions for mounting a lens holder to the PCB using glue. The design is fairly simple. In addition to the array of sensors, there’s an I2C multiplexer which also acts as a level shifter and a handful of resistors and connectors.
Is seven pixels enough to be useful? We don’t know, but we’d love to see some examples of using the SNAIL Vision board, or other low-resolution optical sensors with low-end microcontrollers. This seems like a cheaper mechanism than Pixy. If seven pixels are too much, you could always try one.
Growing your own food is a fun hobby and generally as rewarding as people say it is. However, it does have its quirks and it definitely equires quite the time input. That’s why it was so satisfying to watch Farmbot push a weed underground. Take that!
Farmbot is a project that has been going on for a few years now, it was a semifinalist in the Hackaday Prize 2014, and that development time shows in the project documented on their website. The robot can plant, water, analyze, and weed a garden filled with arbitrarily chosen plant life. It’s low power and low maintenance. On top of that, every single bit is documented on their website. It’s really well done and thorough. They are gearing up to sell kits, but if you want it now; just do it yourself.
The bot itself is exactly what you’d expect if you were to pick out the cheapest most accessible way to build a robot: aluminum extrusions, plate metal, and 3D printer parts make up the frame. The brain is a Raspberry Pi hooked to its regular companion, an Arduino. On top of all this is a fairly comprehensive software stack.
The user can lay out the garden graphically. They can get as macro or micro as they’d like about the routines the robot uses. The robot will happily come to life in intervals and manage a garden. They hope that by selling kits they’ll interest a whole slew of hackers who can contribute back to the problem of small scale robotic farming.
The ModuPong YouTube channel is about a modular robotics system that tracks a ping pong ball in real-time. In addition, we cover in this channel how the system predicts and responds in less than 130ms.
Please tell me if you have any ideas on how we could make our system better. Cheaper and faster would be great!
