Arduino App Lab

Table of Contents

1 Introduction
2 Arduino App Lab
3 Building a Simple App
4 App Code & Demo
5 App Lab Limitations (v 0.3.2)
6 App Lab Alternatives
7 Uno Q Summary
8 Conclusion

In the second installment of our series on the Arduino Uno Q, we will see how we can build “apps” using the new Arduino App Manager. Since the App Manager lacks many features, we will also consider alternative editors for C++ and Python.

Introduction

The Arduino Uno Q represents a significant evolution in the Arduino ecosystem – a unique board that combines both a microcontroller and a microcomputer in the familiar Arduino Uno form factor. To program this hybrid board, Arduino has introduced the App Lab, an integrated development environment designed specifically for creating applications that leverage both processors.

In this article, we’ll explore the Arduino App Lab, learn how to build a simple application that demonstrates communication between the Python and C++ sides of the board, and examine the current state of this early-stage development environment. We’ll also look at alternative editors you can use to work around some of App Lab’s current limitations.

Important Note: This article is based on Arduino App Lab version 0.3.2, recorded in early January 2026. As this is a very early release – not even version 1.0 yet – many features are still missing or incomplete. By the time you read this, Arduino may have addressed many of the limitations discussed here. However, the fundamental concepts of App development and the workarounds presented will still be valuable for understanding how to work with the Arduino Uno Q platform.

What is Arduino App Lab?

Arduino App Lab is an application specifically designed for building apps for the Arduino Uno Q. It provides editors for both Python (which runs on the microcomputer side) and C++ (which runs on the microcontroller side). An “app” in this context is a combination of Python programming for the microcomputer and C++ programming for the microcontroller, working together through Arduino’s bridge communication system.

Running App Lab

The App Lab can be run in three different ways:

Onboard: There’s a copy that runs directly on the Linux partition of the Arduino Uno Q itself
USB Connection: Connect the Arduino Uno Q to a computer via USB-C
Network Connection: Connect to the board over a local area network

Versions of App Lab are available for Linux, macOS, and Microsoft Windows.

Important Concept: File Storage

One crucial concept to understand is that app files reside on the Arduino Uno Q itself, not on your local PC. The App Lab doesn’t make a local copy – it edits files directly on the board. You’ll find these files in the Linux partition at /home/arduino/arduino_apps/.

Even when you run App Lab on your computer, it’s connecting to and editing files that live on the Arduino Uno Q. This is an important distinction from traditional Arduino development.

Arduino Uno Q Architecture

To understand how App Lab works, you need to understand the unique architecture of the Arduino Uno Q:

Microcomputer Side:

Processor: Qualcomm QRB2210
Operating System: Debian Linux
Programming Language: Python

Microcontroller Side:

Processor: STM32U585
Operating System: Zephyr RTOS
Programming Language: C++

The Bridge

To enable communication between the Python and C++ code, Arduino provides something called “the bridge.” This allows:

Calling Python functions from C++
Calling C++ functions from Python
Exchange of data between both processors

This bridge is what makes the dual-processor architecture truly powerful, allowing you to leverage the strengths of both sides.

App Structure

An Arduino app is organized in a specific folder structure:

Python folder: Contains Python files for the microcomputer
Sketch folder: Contains C++ files for the microcontroller
Assets folder: Additional resources (optional)
README.md: Documentation
app.yaml: Configuration file

Apps can also include “bricks” – pre-made building blocks of code that can be called from Python to add advanced functionality.

App Lab Features

The App Lab interface provides several key features:

File Management: Manages all files within your app
Library Manager: Manages C++ library files
Brick Manager: Allows adding pre-built code blocks for advanced features
Dual Editors: Side-by-side Python and C++ editors

Connection Methods

USB-C Connection: This is the most straightforward method. Simply connect your Arduino Uno Q to your computer via USB-C cable and App Lab will detect it.

Network Connection: For network connection, you’ll need to know the IP address of your Arduino Uno Q. You can find this by accessing the Linux partition through SSH or by checking your router’s connected devices list.

Running App Lab Locally on the Uno Q: Since the Uno Q runs Debian Linux, you can also access App Lab directly on the board. This requires connecting a monitor and keyboard to the board.

Building a Simple App

Let’s build a simple app to demonstrate how the dual-processor architecture works. Our example will flash an LED and control its flash rate with a potentiometer – a classic Arduino project with a twist.

The Concept

Our app will demonstrate the bridge communication system:

The C++ side will read the potentiometer value and control the LED
The Python side will read data from the C++ side via the bridge
Both processors will work together seamlessly

Creating a New App

In App Lab, create a new app:

Click “New App”
Name it something descriptive (e.g., “PotLED”)
The App Lab will create the basic folder structure automatically

The C++ Side (Microcontroller)

The C++ code runs on the STM32U585 microcontroller and handles the real-time hardware control. Here’s what our sketch does:

/*
  Simple App Demp - Variable-Speed Blinker
  sketch.ino
  Shows the structure of a simple Arduino Uno Q App
  Blinks LED, with speed set by potentiometer
  LED pin D9, Pot pin A0
  DroneBot Workshop 2026
  https://dronebotworkshop.com
*/

// Include Arduino Router_Bridge Library
#include <Arduino_RouterBridge.h>

// Define I/O pins
const int potPin = A0;
const int ledPin = 9;

// Global blink delay
volatile int blinkDelay = 1000;
unsigned long previousMillis = 0;
int ledState = LOW;

// EXPOSED FUNCTION 1: Python asks, "What is the pot value?"
int get_pot_value() {
  return analogRead(potPin);
}

// EXPOSED FUNCTION 2: Python says, "Set the blink rate to X."
void set_blink_rate(int rate) {
  if (rate < 50) rate = 50;
  if (rate > 2000) rate = 2000;
  blinkDelay = rate;
}

void setup() {

  // Set LED Pin as Output
  pinMode(ledPin, OUTPUT);
  
  // Start Bridge
  Bridge.begin();
  
  // Register functions for Python to call
  Bridge.provide("get_pot_value", get_pot_value);
  Bridge.provide("set_blink_rate", set_blink_rate);
}

void loop() {

  // Update the bridge
  Bridge.update(); 

  // Non-blocking blink logic
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= blinkDelay) {
    previousMillis = currentMillis;
    ledState = (ledState == LOW) ? HIGH : LOW;
    digitalWrite(ledPin, ledState);
  }
}

Simple App Demp - Variable-Speed Blinker

sketch.ino

Shows the structure of a simple Arduino Uno Q App

Blinks LED, with speed set by potentiometer

LED pin D9, Pot pin A0

DroneBot Workshop 2026

https://dronebotworkshop.com

// Include Arduino Router_Bridge Library

#include <Arduino_RouterBridge.h>

// Define I/O pins

const int potPin = A0;

const int ledPin = 9;

// Global blink delay

volatile int blinkDelay = 1000;

unsigned long previousMillis = 0;

int ledState = LOW;

// EXPOSED FUNCTION 1: Python asks, "What is the pot value?"

int get_pot_value() {

return analogRead(potPin);

}

// EXPOSED FUNCTION 2: Python says, "Set the blink rate to X."

void set_blink_rate(int rate) {

if (rate < 50) rate = 50;

if (rate > 2000) rate = 2000;

blinkDelay = rate;

}

void setup() {

// Set LED Pin as Output

pinMode(ledPin, OUTPUT);

// Start Bridge

Bridge.begin();

// Register functions for Python to call

Bridge.provide("get_pot_value", get_pot_value);

Bridge.provide("set_blink_rate", set_blink_rate);

}

void loop() {

// Update the bridge

Bridge.update();

// Non-blocking blink logic

unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= blinkDelay) {

previousMillis = currentMillis;

ledState = (ledState == LOW) ? HIGH : LOW;

digitalWrite(ledPin, ledState);

}

Key Points:

We include Arduino_RouterBridge.h to access bridge functionality
RouterBridge.begin() initializes communication
RouterBridge.write() sends data to the Python side
The microcontroller handles the time-critical LED flashing

The Python Side (Microcomputer)

The Python code runs on the QRB2210 microcomputer and can process data, provide user interfaces, or handle more complex operations:

# Simple App Demp - Variable-Speed Blinker
# main.py
# Shows the structure of a simple Arduino Uno Q App
# Blinks LED, with speed set by potentiometer
# LED pin D9, Pot pin A0
# DroneBot Workshop 2026
# https://dronebotworkshop.com

import time
from arduino.app_utils import Bridge

def main():
    print("Uno Q Polling App Started")
    
    while True:
        try:
            # 1. POLL: Ask C++ for the current pot value
            # This is a safe request/response cycle
            raw_val = int(Bridge.call("get_pot_value"))
            
            # 2. CALC: Do the math
            new_delay = int((raw_val / 4095) * 950) + 50
            
            # 3. COMMAND: Tell C++ the new rate
            # This is a separate request/response cycle
            Bridge.call("set_blink_rate", new_delay)
            
            # Optional: print(f"Read: {raw_val} -> Set: {new_delay}")
            
        except Exception as e:
            print(f"Bridge Error: {e}")

        # Sleep to avoid taxing the CPU
        time.sleep(0.05) 

if __name__ == '__main__':
    main()

# Simple App Demp - Variable-Speed Blinker

# main.py

# Shows the structure of a simple Arduino Uno Q App

# Blinks LED, with speed set by potentiometer

# LED pin D9, Pot pin A0

# DroneBot Workshop 2026

# https://dronebotworkshop.com

import time

from arduino.app_utils import Bridge

def main():

print("Uno Q Polling App Started")

while True:

try:

# 1. POLL: Ask C++ for the current pot value

# This is a safe request/response cycle

raw_val = int(Bridge.call("get_pot_value"))

# 2. CALC: Do the math

new_delay = int((raw_val / 4095) * 950) + 50

# 3. COMMAND: Tell C++ the new rate

# This is a separate request/response cycle

Bridge.call("set_blink_rate", new_delay)

# Optional: print(f"Read: {raw_val} -> Set: {new_delay}")

except Exception as e:

print(f"Bridge Error: {e}")

# Sleep to avoid taxing the CPU

time.sleep(0.05)

if __name__ == '__main__':

main()

Key Points:

Import RouterBridge from the router_bridge module
Use bridge.read() to receive data from C++
The Python side can perform higher-level processing, logging, or user interface tasks

How the Bridge Works

The RouterBridge creates a communication channel between the two processors:

The C++ side writes data using RouterBridge.write()
This data is transmitted through the bridge
The Python side receives it using bridge.read()
Both processors continue running independently

This allows you to leverage the real-time capabilities of the microcontroller while using Python’s extensive libraries and processing power on the microcomputer side.

App Code & Demo

Running the Application

To run your app in App Lab:

Make sure both the Python and C++ code are saved
Click the “Run” button in App Lab
The app will compile the C++ code and deploy it to the microcontroller
The Python code will start running on the microcomputer

Observing the Results

When you run the potentiometer-LED app:

LED Behavior: The built-in LED will flash at a rate determined by the potentiometer position
Console Output: The Python console will display the potentiometer values being read
Real-time Response: As you turn the potentiometer, both the flash rate and console output will change immediately

What This Demonstrates

This simple app demonstrates the core concept of the Arduino Uno Q architecture:

Hardware Control: The microcontroller handles precise timing and direct hardware manipulation
Data Processing: The microcomputer can monitor, log, or process the data
Seamless Integration: Both processors work together through the bridge with minimal latency

In more complex applications, you might use the microcontroller for sensor reading and motor control while the microcomputer handles artificial intelligence, image processing, or web services.

App Lab Limitations (v 0.3.2)

While App Lab provides the basic functionality needed to develop for the Arduino Uno Q, version 0.3.2 has several significant limitations that can impact your development experience.

Editor Limitations

The built-in code editors lack many features that developers have come to expect from modern IDEs:

Missing Features:

No Find and Replace: You cannot search for text within your code, making navigation difficult in larger files
Limited Syntax Highlighting: Basic highlighting exists but lacks the sophistication of dedicated editors
No Auto-completion: You won’t get IntelliSense or auto-complete suggestions
No Code Folding: Cannot collapse functions or code blocks for better organization
Limited Undo History: The undo buffer is quite limited
No Multiple Cursor Support: Cannot edit multiple lines simultaneously

Workarounds: The most practical approach is to use external editors (covered in the next section) and only use App Lab for deployment and running your apps.

File Management Issues

Opening Files: The file opening mechanism is problematic. When you try to open a file, it doesn’t always provide a proper file browser or respect standard file paths. This makes importing existing code or organizing projects challenging.

Non-functional Features: Some file management features that appear in the interface don’t actually work in version 0.3.2, leading to confusion about what’s possible.

Library Management

The library manager for C++ libraries has limited functionality:

Adding custom libraries can be difficult
The interface doesn’t always refresh properly after adding libraries
Some libraries may not install correctly

Debugging Limitations

No Integrated Debugger: There’s no step-through debugging capability. You’ll need to rely on print statements and serial output for troubleshooting.

Console Output: While you can see Python print statements, the console output handling could be more robust, especially when dealing with errors.

General Stability

As early-release software, App Lab can occasionally:

Freeze or become unresponsive
Lose connection to the board requiring a restart
Have sync issues between the interface and actual file contents on the board

Performance

The editors can feel sluggish, especially when:

Working with larger files
Switching between Python and C++ views
Running and stopping apps repeatedly

The Bottom Line

These limitations are significant but not insurmountable. Arduino is actively developing App Lab, and many of these issues will likely be resolved in future versions. For now, knowing these limitations helps you plan your workflow and utilize workarounds effectively.

The core functionality – building, deploying, and running apps – does work, which is the most important aspect. The editor limitations are the most significant pain point, which leads us to exploring alternatives.

App Lab Alternatives

Given App Lab’s current editor limitations, you’ll likely want to use external editors for actual code development. Here are several approaches that work well with the Arduino Uno Q workflow.

Visual Studio Code (VS Code)

Best For: Most developers, especially those working with both Python and C++

Setup:

Install VS Code on your computer
Access the Arduino Uno Q’s filesystem via SSH or network share
Edit files directly on the board’s /home/arduino/arduino_apps/ directory

Advantages:

Excellent Python and C++ support
Full IntelliSense and auto-completion
Integrated terminal
Git integration
Extensions for Arduino development
Find and replace across multiple files
Multiple cursor editing
Customizable themes and layouts

Workflow:

Write and edit code in VS Code
Save changes (they’re automatically on the board since you’re editing the network location)
Switch to App Lab to run and deploy the app
Monitor output in App Lab’s console

PyCharm

Best For: Python-focused development

If your app is heavily Python-based with minimal C++ code, PyCharm offers exceptional Python development features:

Professional Python debugging
Code quality analysis
Virtual environment management
Database tools for data logging

Arduino IDE 2.0

Best For: C++ sketch development

For the C++ side, the traditional Arduino IDE 2.0 can be used:

Familiar interface for Arduino developers
Better C++ syntax highlighting than App Lab
Library manager
Serial monitor

Limitation: This only helps with the C++ side; you’ll need a separate editor for Python.

Sublime Text or Notepad++

Best For: Lightweight editing, quick changes

These text editors offer:

Fast performance
Good syntax highlighting
Find and replace
Multiple file handling
Low resource usage

Vim or Emacs

Best For: Terminal-based editing, SSH access

If you’re comfortable with terminal editors, you can:

SSH directly into the Arduino Uno Q
Edit files in their native location using vim or emacs
Never leave the terminal environment

Recommended Workflow

Here’s the workflow I recommend for most developers:

Code Development: Use VS Code or your preferred editor to write and edit Python and C++ files
File Access: Connect to the Arduino Uno Q via network share or SSH to access /home/arduino/arduino_apps/
Testing and Deployment: Use App Lab exclusively for:
- Running apps
- Deploying to the board
- Monitoring console output
- Managing bricks and libraries
Version Control: Keep your code in git, making regular commits as you develop

Accessing Files Over the Network

To edit files directly on the Arduino Uno Q from your computer:

On Linux/Mac:

# Mount the Arduino's filesystem
sshfs arduino@&lt;uno-q-ip-address&gt;:/home/arduino/arduino_apps ~/arduino_apps

# Now edit files in ~/arduino_apps with your preferred editor

# Mount the Arduino's filesystem

sshfs arduino@<uno-q-ip-address>:/home/arduino/arduino_apps ~/arduino_apps

# Now edit files in ~/arduino_apps with your preferred editor

On Windows:

Use WinSCP or FileZilla to access files via SFTP
Map a network drive to the Arduino’s filesystem
Use VS Code’s Remote-SSH extension

The Hybrid Approach

This hybrid approach – external editor for coding, App Lab for deployment – gives you the best of both worlds:

Professional development tools
Access to App Lab’s deployment and brick management
Faster, more efficient coding
Better debugging capabilities

Uno Q Summary

After working extensively with the Arduino Uno Q, here are my honest observations about the platform as it exists in early 2026.

The Concept is Revolutionary

The idea of combining a microcontroller and microcomputer on a single board in an Arduino form factor is genuinely innovative. This architecture opens up possibilities that weren’t practical before:

Real-time sensor control paired with AI processing
Complex algorithms running alongside hardware timing
Web interfaces combined with GPIO control
Camera integration with motor control

The potential applications are exciting, especially in robotics, industrial automation, and IoT projects.

The Execution Needs Work

However, the current implementation feels rushed. Several indicators suggest this board was brought to market before it was truly ready:

Missing Essential Accessories: The Arduino Uno Q has connectors for CSI cameras (J-MIPI-CSI and J-Media), but as of this writing, there’s no carrier board or camera module available to purchase. This seems like a significant oversight – the ability to process camera data was clearly a major design goal, yet you cannot actually connect a camera without building custom hardware.

You can connect a USB webcam through a hub, but that defeats the purpose of having a compact, integrated platform. For robotics applications especially, having to add a USB hub and webcam makes the board far less practical.

Software Immaturity: App Lab at version 0.3.2 is clearly beta software. The missing features and non-functional elements suggest it should have had more development time before release. While the core functionality works, the development experience is frustrating compared to mature IDEs.

Timing with Qualcomm Acquisition

The timing of the Uno Q release coincided with Arduino’s acquisition by Qualcomm. While this is pure speculation, it appears the board may have been rushed to market to coincide with that announcement. A few more months of development could have resulted in:

Available camera accessories
More polished App Lab software
Better documentation
More example projects

The Platform Has Potential

Despite these criticisms, I remain optimistic about the Arduino Uno Q platform:

Hope for Improvement: Arduino has a track record of supporting and improving their products. I expect to see:

App Lab maturing rapidly with updates
Camera accessories becoming available
Growing library of example apps and bricks
Community-developed resources

Series Potential: I hope the Uno Q is the first of a series of Q-series boards. A Nano Q would be fantastic, though the technical challenges of fitting both processors and memory into that form factor may be significant.

Competition Would Help: The ideal scenario would be competition in this space. Raspberry Pi would be a natural competitor – they make both the world’s most popular single-board computer and their own line of microcontrollers. A board combining a Pi Zero with a Pico would be a compelling alternative.

Competition typically drives innovation and keeps prices competitive, so other manufacturers entering this dual-processor space would benefit everyone.

My Recommendation

For Early Adopters: If you’re comfortable working with beta software, enjoy problem-solving, and want to explore the cutting edge of Arduino development, the Uno Q is an interesting platform to experiment with. Just go in with realistic expectations about the current limitations.

For Production Projects: I would recommend waiting for the platform to mature. Give Arduino time to:

Release version 1.0 of App Lab
Make camera accessories available
Build a more complete documentation ecosystem
Work out the rough edges

For Educational Use: The Uno Q introduces important concepts about multiprocessor coordination and hybrid computing. However, the current development experience is frustrating enough that it might discourage beginners. Once App Lab matures, this could become an excellent teaching platform.

Final Thoughts

I purchased four Arduino Uno Q boards because I believe in the concept and want to support Arduino’s innovation. I’ll continue working with them and documenting what I learn. The fundamentals are sound – it’s just a matter of the ecosystem catching up to the hardware’s potential.

The bridge communication system works well, the dual-processor architecture is powerful, and the board is well-designed physically. These strengths give me confidence that with time and development, the Arduino Uno Q will become a truly excellent platform.

Conclusion

The Arduino Uno Q represents an ambitious step forward in Arduino’s evolution, bringing together microcontroller and microcomputer capabilities in a familiar form factor. While the current state of the platform shows its early-stage nature – particularly in the App Lab development environment – the fundamental architecture is sound and full of potential.

What We’ve Covered

In this article, we explored:

Arduino App Lab: The specialized IDE for building Uno Q apps
App Structure: How Python and C++ work together through the bridge
Practical Development: Building a simple app that demonstrates inter-processor communication
Current Limitations: The realistic constraints of version 0.3.2
Alternative Workflows: Using professional editors while leveraging App Lab for deployment
Platform Assessment: An honest evaluation of the Uno Q’s current state

Key Takeaways

The Architecture Works: The bridge communication between processors is effective and opens new possibilities
Use External Editors: Don’t struggle with App Lab’s limited editors when professional tools are available
Expect Evolution: This is early-stage software that will improve significantly
Plan for Workarounds: Understanding the limitations helps you develop effective strategies
The Concept is Sound: Despite current rough edges, the dual-processor approach has genuine merit

Moving Forward

The Arduino Uno Q journey is just beginning. Future articles will explore:

Building more complex apps with bricks
Artificial intelligence integration
Camera applications (when hardware becomes available)
Advanced bridge communication techniques
Real-world project implementations

Looking Ahead

As App Lab matures and the ecosystem develops, the Arduino Uno Q has the potential to become a go-to platform for projects that need both real-time hardware control and high-level processing power. The combination of Arduino’s accessibility with serious computing capability could open embedded development to a broader audience.

For now, approach the platform with patience, use the workarounds presented in this article, and enjoy being on the cutting edge of Arduino innovation. The bumps along the way are part of exploring new technology, and the community you’re helping to build will benefit everyone who follows.

Whether you’re building your first app or planning complex projects, the principles covered here will serve as a foundation for your Arduino Uno Q development. Keep experimenting, share what you learn, and watch as this platform evolves.

Stay Connected

For more information, example code, and ongoing updates about the Arduino Uno Q:

Visit the DroneBot Workshop website at dronebotworkshop.com
Join the discussion in the DroneBot Workshop forum
Subscribe to the newsletter for updates on new projects and tutorials
Watch for future videos exploring advanced Uno Q applications

The Arduino Uno Q is not just a new board – it’s a new way of thinking about embedded development. As the platform matures, I’ll continue documenting the journey and sharing what I learn with the DroneBot Workshop community.

This article is based on Arduino App Lab version 0.3.2 and the state of the Arduino Uno Q platform as of January 2026. Features and capabilities may have improved since this writing.

Arduino App Lab – Build Your First App

1 Comment

Oldest

Newest

Inline Feedbacks

View all comments

John Fletcher

2 months ago

Arduino App Lab 0.3.2 Database Brick. I am having difficulty with this. The database exists although it is not located where the documentation says it is (/data). It must be somewhere. It can disappear, I think when the App Lab crashes.
On other things I have more success and use MobaXterm to move files and run things on the UNO Q. I have installed C++ and Geany to edit projects. I use SWIG to make C++ code available from Python.