Cyberdecks don’t all have to be chunky slabs of aluminum and plastic chasing after an ‘80s cassette futurism aesthetic. Cyberdecks can be whatever their builders want them to be — that’s the whole appeal. Jen Looper is a creative technologist who loves nature, plants, and cozy gardens, so she built this #cottagecore cyberdeck to do literal fieldwork.
As an aesthetic, cottagecore is all about cozy, rustic vibes. As a subculture, it is about comfortable sustainability and “slow living.” B.L.O.O.M. (Bridging Local Observations, Openly Mapped) is a cyberdeck designed to encompass all of that. Looper built it for collecting field notes on regional plants and animals. It harkens back to the descriptive logging and taxonomic classification work of Victorian naturalists.
The physical construction is also the polar opposite of what we typically see from the cyberdeck community. The enclosure is a “train case,” which is a traditional piece of luggage used for carrying cosmetics and grooming supplies. All of the hardware components nestle inside, with plenty of room to spare for some paper notebooks.
The hardware consists of an Arduino® UNOQ (4GB), a 5” HDMI screen, a Bluetooth keyboard, a Bluetooth mouse, and a power bank to power it all. It also has a USB camera and a USB microphone, which can be used for data collection.
To that end, it connects with a companion app (Field Notes) to compile that data in the Grinnell format. It can also run local AI models directly on the UNO Q to help with that work. As an example, Looper employed the Edge Impulse integration in Arduino App Lab to create a custom model that can recognize avian species based on their birdsong.
This is the kind of functionality that Victorian naturalists wouldn’t have even been able to dream of, but Looper was able to achieve it on a modest budget. At the same time, she proved that cyberdecks can come in any form.
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.
The Arduino core for Zephyr RTOS has reached version 1.0.0. This release marks the completion of the transition away from the old MbedOS-based core. The new core provides a modern and flexible foundation for current and future Arduino boards. It also lets you use Zephyr RTOS features and APIs directly from the Arduino IDE, Arduino CLI and Arduino App Lab tools.
The project is built on a two-component architecture. The core generates a standalone elf file that is loaded dynamically by a precompiled Zephyr firmware called the loader. The loader handles the interaction between sketches and the underlying Zephyr system. After the initial bootloader installation, the loader automates the sketch loading process. Version 0.90.0 made the Zephyr loader installation procedure fully automatic.
The loader and its operating modes
The loader’s behaviour is set through the IDE’s Mode menu. In Standard mode, the loader loads the sketch automatically. In Debug mode, on the other hand, it requires you to type ‘sketch’ in the Zephyr shell. This flexibility makes debugging much easier. The loader design is generic: board-specific changes are made in the DTS overlay or fixup files.
The core is validated with version v0.16.8 of the Zephyr SDK. Development uses the standard tools of the Zephyr ecosystem, such as west and sync-zephyr-artifacts. The core also relies on components such as llext, the dynamic extension mechanism, and zephyr-sketch-tool for compiling sketches. Everything rests on ArduinoCore-API to maintain compatibility with the Arduino ecosystem.
What you need to get started
To try the Zephyr core you need a supported board and an up-to-date development environment. Here are the main steps:
Install Arduino IDE 2.x.x or Arduino CLI
Add board support through the Board Manager
Install the Zephyr core from version 1.0.0
Configure the loader mode from the IDE’s Mode menu
Version 1.0.0 of the Zephyr core is a milestone release. The move from MbedOS to Zephyr is complete. The new core offers a more solid foundation for the future of Arduino boards. Among the new features, support for the project’s code repository includes all the loader and core sources. In addition, the new Arduino UNO Q board is among the first devices to benefit from this architecture.
Arduino’s Zephyr core, designed to replace the MbedOS version, has reached release 1.0.0 and now supports the VENTUNO Q.
The Zephyr core represents a paradigm shift for Arduino. It is not just an update: it is an infrastructure built to last. The separation between loader and sketch makes the system safer and easier to update. What’s more, using Zephyr RTOS opens the door to advanced features such as support for numerous protocols and optimised power management. For anyone developing IoT applications, this is a solid foundation to build on.
The transition from MbedOS to Zephyr was not only technical, but also strategic. Zephyr is an open source RTOS with an active community and a regular release cycle. This guarantees long-term support for Arduino boards. In addition, version 1.0.0 of the core is validated with the Zephyr SDK v0.16.8, ensuring stability and compatibility. The future of Arduino boards goes through here.
When you look into the night sky, you can’t help but wish to bring the outer worlds to your doorstep. One of the best ways to do that is to photograph the Moon’s surface to display in a frame. However, [Sebastian Lague] found a simple image too lackluster compared to something with a bit more style, such as a plotted image of the lunar terrain.
Why plotting? Well, the Moon is not defined in the same way with contrasting colors as Earth is. The Moon is peppered with craters and differing elevations that separate regions, so why not build an entire DIY plotter from scratch? [Sebastian Lague] did exactly this with a custom algorithm to take the elevation maps and create vector drawings which are plotted on his custom plotter.
Plottings of Earth, the Moon, and Mars
The plotter’s design is simple on its face, using an Arduino and stepper motors, as many other plotters have. [Sebastian Lague] also shares insights into their process and iterative designs, moving from a level arm to raise a marker to a linear method. While the Moon plots are impressive on their own, why stop there? [Sebastian Lague] decided to plot Mars and then return home with Earth plots.
While the plotter itself is rather simple, all the work behind the contour maps and turning the ideas into reality is nothing to take for granted. However, if you want a more complicated side of plotting, make sure to check out this multi-colored delta plotter!
A group of children aged 7 to 13 is building a tactile zoo with 3D-printed robotic animals. The creatures, more than 20 in total, are equipped with LEDs, motors, buttons, and gears. At Maker Faire Bay Area, the group will also display their printing errors and failed prototypes. The goal is to show the iteration process that leads from an idea to a working object.
The project turns 3D printing into an educational and interactive activity. Mistakes are not hidden but become an integral part of the exhibition. Visitors can thus understand that making errors is a normal step in the work, not a failure. The maker’s website details how the children faced technical difficulties and what solutions they found.
From choosing the animal to the first print
Each young maker chooses an animal, real, mythological, or completely invented. Then they decide what behavior the creature should have. Some design the animals from scratch, others start from existing 3D models and modify them, cutting or redesigning sections to make room for the electronics. Once the body is ready, they add a function such as an LED, a servo, a motor, a button, or a set of gears.
The group includes eight creatures, among them Em. To make Plate the Armadillo roll into a ball, 11 prints were needed. Each failed attempt taught something new: a joint too tight, a motor off-axis, a wall too thin. The children learned to observe the error and correct it in the next print.
An exhibition you can touch and open
The zoo is not a simple showcase. Visitors can press buttons, flip switches, and open the animals to see the wires, gears, and electronics inside. This choice makes the electronics transparent and understandable even to those who have never opened a device. Next to the finished animals, broken prints, melted parts, and earlier versions are displayed, so visitors can ask what went wrong and how it was fixed.
For those who want to recreate the project, the electronic part can be built with simple, modular components. For example, a servo motor with metal gears can move an animal’s legs, while a shield for controlling RC servos allows managing multiple movements with an Arduino board. For light effects, a WS2812 LED matrix offers endless color possibilities. Finally, a compact board like the Arduino Nano Matter can handle logic and connectivity in a small space.
Mistakes on display: the educational value of failure
The choice to display printing errors is the heart of the project. In a world that shows only perfect results, these children reveal the behind-the-scenes. The broken prints tell the real difficulties of 3D printing: material shrinkage, parts detaching from the bed, motors that don’t find space. Visitors to Maker Faire will be able to talk with the young makers and discover how each problem was tackled.
This approach also changes the way the children work. They learn that a failed prototype is not wasted time, but a step forward. Each error provides valuable information for the next version. The iteration process thus becomes a mental habit, useful not only in 3D printing but in every design activity.
We’re living in 2026 and everyone knows that they can ask a large language model (LLM) a question and get an answer. But most people assume that requires an internet connection, because those LLMs live in massive data centers. The truth is that LLMs can run on local hardware, answering questions without any internet at all. Cameron Coward, of the Serial Hobbyism YouTube channel, took advantage of that fact, connecting an Arduino UNO Q to a vintage terminal.
That terminal is a Texas Instruments Silent 700 (Model 745), which is a paper terminal that was made in the 1970s. Back then, it would have been used as an input/output device for something like a minicomputer, connected through either an acoustic coupler (remote) or RS232 (local). Users would type commands on the keyboard and computer output would print on the thermal paper.
For this project, Coward connected the Silent 700 to his custom-built device, Termi3, to give it the ability to answer questions. The user types a question and a moment later, the terminal prints out the answer.
As the name suggests, Termi3 is the third version of the device. The first two required internet access, because they retrieved answers through the Wolfram Alpha API.
Termi3 doesn’t need any internet connection at all, because it generates an answer locally on an UNO Q (2GB). The Arduino runs a local LLM, Llama 3.2-1B, on the Linux side without ever touching a network. It interfaces with the terminal though bit-banging on the STM32 side, which goes through a MAX3232 transceiver (for level conversion) to the terminal’s RS232 port.
It is amazing that an LLM can run on the small and affordable UNO Q at all, especially with 2GB of RAM. So, the LLM isn’t particularly sophisticated and its answers aren’t always accurate — or even coherent. But they are often entertaining, which makes Termi3 a lot of fun to talk to.
Not a lot of thought went into the “mouse droid” in the first Star Wars movie. It was just a bit of cute world-building, created by putting a box on an RC car. But it became a fan favorite and that in-universe model, the MSE-6, appears throughout subsequent movies, TV shows, and video games. All of them, however, are identical. Cass, the maker behind Chaos Theory, imagined how mouse droids would actually fit into the world and the result is this MSE-6 that knows how to party.
According to the lore, billions of MSE-6 droids were built. For those living in the Star Wars universe, they wouldn’t be any more special than toasters or Huffy bicycles. It is only natural that individuals in that universe would customize mouse droids and Cass’ creation is an exploration of the kind of personalization that Sabine Wren would perform.
For those who aren’t deep into Star Wars lore, the simpler explanation is that this is an adorable mouse droid capable of navigating autonomously and features blinky lights, a radical paint job, and a rave mode. In that mode, it turns into a graffiti-covered mobile party machine that spins around while blasting music and flashing its lights.
Underneath the 3D-printed shell in that iconic shape, this is an Arduino UNO Rev3-controlled rover robot. It has a pair of motors, which the Arduino controls through an L298N driver. Power comes from a 7.4V lithium battery pack, with a buck converter to reach 5V. An ultrasonic sensor prevents collisions and the sound plays through a DFPlayer Mini MP3 module. Finally, arrays of 5mm red LEDs provide visual flair.
That all came together thanks to Cass’ fantastic paint job. She explains her inspiration, thought process, and supplies, but the great results are mostly attributable to her artistic talent. It is exactly the kind of mouse droid that Sabine Wren would adopt.
This Arduino UNO Q Headband Uses 13 Vibration Motors for Screen-Free Awareness Through Haptic Feedback
Maker pasquale887 developed HaloSense V1, an Arduino UNO Q-powered haptic headband using 13 vibration motors for screen-free awareness. It helps users sense directions, people, and objects through…
An SO-101 robot arm, originally a desktop toy, now picks and places rubber ducks by reasoning with a vision-language-action model. Dmitry Maslov’s project swaps the original brain for an Arduino VENTUNO Q board, which runs Hugging Face’s SmolVLA model locally. The result shows that robotics tasks combining vision and language, once confined to costly labs, now fit on a 299-dollar board.
Hardware: two processors on one board
The Arduino VENTUNO Q board has a dual nature. On one side sits an SBC system with a Qualcomm Dragonwing IQ8 processor, equipped with an Adreno 623 GPU and a Hexagon Tensor NPU, built for AI processing. On the other side is an STM32H5F5 microcontroller with an Arm Cortex-M33 core running at 250 MHz, which handles real-time servo control. The board offers 16 GB of LPDDR5 RAM and 64 GB of integrated eMMC storage.
The original SO-101 arm carries gearmotors on every joint and two cameras: one fixed overhead and one on the gripper. The images and joint position data go to the Dragonwing IQ8 processor, where the SmolVLA model interprets them. The model was trained with 50 demonstrations of the task of grabbing and moving the rubber ducks.
The SmolVLA model and the system’s numbers
SmolVLA is an open source vision-language-action model from Hugging Face. It processes the camera images and joint data, then produces the commands for the servo motors. All the processing happens locally on the VENTUNO Q board, with no connection to external services. The board costs 299 dollars, against 399 dollars for the Jetson Orin Nano Super Developer Kit, cited as a competitor.
Dmitry Maslov’s system points the way to accessible robotics. What’s more, the fact that the model runs on a commercial board costing less than 300 dollars opens up new scenarios for makers. For anyone who wants to see the project in action, Dmitry Maslov’s video shows the arm grabbing and moving the rubber ducks.
Arduino VENTUNO Q board with Qualcomm Dragonwing IQ8 processor and STM32H5F5
Hugging Face SmolVLA model running locally
50 demonstrations to train the pick-and-place task
Two cameras: one overhead and one on the gripper
16 GB of LPDDR5 RAM and 64 GB of eMMC storage
For anyone wanting to rebuild the project, the trickiest part is the integration between the SBC side and the microcontroller side of the board. The Dragonwing IQ8 processor runs the model, while the STM32H5F5 controls the servos. Communication between the two sides is essential to synchronise vision with movement.
