VTM Studio 2.2.0 · First-Party Hardware Telemetry & Architecture Card

Physical AI & Edge Workstation Benchmarks.

A transparent, reproducible hardware benchmark report measuring VTM Studio 2.2.0 running Gemma 3 1B (Q4_K_M), live UI token streaming, and concurrent Piper ONNX text-to-speech synthesis inside the 3.58 GB usable RAM envelope of the 4 GB Arduino UNO Q (ABX00173)—paired with cross-platform desktop scaling and a respectful architectural comparison alongside Arduino App Lab, Professor Marcelo Rovai's UNO Q curriculum, and Cirkit Designer [1–8].

UNO Q 4GB Sustained Avg
1.34–2.00 tok/s
2.00 tok/s Phase 1 · 1.34 tok/s w/ TTS [4]
Decode-to-First-Speech
6.56 sec
After Token 1 (~33.8s total wall-clock vs ~59.2s) [4, 6]
Usable RAM Envelope
3.58 GB
Full GUI + 3 Packs + LLM + TTS · 0 OOM [4]
Desktop Scaling
3.94 tok/s
1B Q4 on 8GB Mac (Logged) · ~32 tok/s 12B RTX 3060 (Obs.) [4]
01 // MEASURED PERFORMANCE CHARTS

Hardware Keynote & Model-Card Benchmark Comparison

All single-board computer measurements below were captured on an unmodified 4 GB Arduino UNO Q (SKU ABX00173) running aarch64 Linux 6.16.7 #1 SMP PREEMPT with 3.58 GB usable system RAM, Python 3.12.8, and VTM Studio 2.2.0 with all three commercial packs (maker, maker_pro, physical_ai_pro) loaded in the graphical Electron interface [1, 4].

Benchmark 01 // Sentence-Boundary Voice Trigger (Lower Is Better)

Decode Wait Before Speech Synthesis on Arduino UNO Q (4 GB)

25.4s EARLIER

In the logged 43-token MicroPython query (following a 27.2 s pre-first-token prompt evaluation wait), a full-completion baseline calculated from the same token timestamps waits all 31.98 s of decoding before invoking TTS. VTM Studio dispatches Sentence 1 to Piper ONNX at Token 14 (6.56 s after Token 1) while Sentence 2 continues generating [4, 6]:

Sentence-Boundary Piper Trigger (Token 14 · ~33.8s Total Wall-Clock) 6.56 s decode
6.56 s
Full-Completion Baseline (Token 43 Finish · ~59.2s Total Wall-Clock) 31.98 s decode
31.98 s decode (~79% longer decode wait · ~43% longer total turn)
Result: Spoken audio synthesis begins 25.42 seconds earlier (~79% shorter decode wait, or ~43% shorter total wall-clock wait including prompt processing) while Sentence 2 continues streaming to the screen.
Benchmark 02 // Logged Gemma 3 1B Q4 Decode Throughput (Higher Is Better)

2017 MacBook Pro (8 GB) vs. UNO Q (4 GB) Decode Phases

1.34–5.41 TOK/S

Logged Gemma 3 1B Q4 token generation speed comparing the 2017 Intel MacBook Pro (8.0 GB RAM) against the UNO Q's 2.0 GHz quad-core Cortex-A53 (QRB2210) across its three decode phases while running the Electron UI and 3.0s /system_stats telemetry [1, 4, 5]:

2017 MacBook Pro 8GB · Prompt 3 Code Block Avg (69 Tokens) 5.41 tok/s
2017 MacBook Pro 8GB · Combined 210-Token Avg (w/ Piper TTS) 3.94 tok/s
Phase 1 Sustained Pure Decode (Tokens 1–15 · 7.035 s) 2.00 tok/s
Phase 3 Post-TTS Sustained Decode (Tokens 23–43 · 12.963 s) 1.54 tok/s
Full 43-Token Turn Average (Includes Parallel Piper ONNX Synthesis) 1.34 tok/s
Benchmark 03 // Cross-Platform Local Edge AI Scaling

Same VTM Studio Edge Engine Across SBCs, Laptops & Desktop GPUs

+ 1-Click UI Toggle to Cloud AI (Google Gemini / Groq)
12 GB NVIDIA RTX 3060 Desktop GPU (12B Gemma GGUF [Observed Reference]) ~32.0 tok/s
2017 Intel MacBook Pro · 8.0 GB RAM (Verified Log: Prompts 2–4 Combined Average) 3.94 tok/s Combined Average (210 Tokens)
2017 Intel MacBook Pro · 8.0 GB RAM (Verified Log: 69–91 Tok + Piper TTS) 3.24–5.41 tok/s
Desktop Integrated iGPU (12B Gemma Fallback [Observed Reference]) ~3.7 tok/s
Arduino UNO Q · 4 GB (Gemma 3 1B Q4 + Full GUI + Concurrent Piper TTS) 1.34–2.00 tok/s (~27s First-Token Wait)
Windows 10 · 4 GB GPU / 24 GB RAM / SSD (2.7B Phi-2 Q8_0 [Observed Reference]) ~2.0 tok/s
Matched 4-Prompt Head-to-Head Telemetry // 2017 Intel MacBook Pro (8.0 GB RAM) vs. Arduino UNO Q (4 GB / 3.58 GB Usable RAM)

Both machines ran the exact same four prompts in VTM Studio 2.2.0 (Gemma 3 1B Q4 + live X-Panel Inference Monitor streaming + sentence-boundary Piper ONNX TTS /generate_audio_chunk WAV synthesis + 3.0s /system_stats polling):

Test Prompt (Identical Across Both Machines) 2017 MacBook Pro (8.0 GB RAM · x86_64) Arduino UNO Q (4 GB / 3.58 GB RAM · aarch64) Laptop vs. SBC Speedup
1. Basic Arithmetic ("7 + 5 = ?") 6 tokens in 0.39 s decode (12.82 tok/s) · ~9.0s first-token wait (9.7s total) 6 tokens · 29.0s total turn (first-token wait + decode + TTS) 2.99× faster total turn
2. Short Story (≤100 Words + Multi-Chunk TTS) 91 tokens in 25.18 s decode (3.61 tok/s overall · 6.22 tok/s Sent. 1) · 34.6s total ~110 tokens · 114.0s total turn (first-token wait + decode + TTS) 3.29× faster total turn
3. C++ Arduino Blink Snippet (No Comments) 69 tokens in 12.75 s decode (5.41 tok/s sustained) · ~9.1s first-token wait (22.0s total) ~45 tokens · 61.0s total turn (first-token wait + decode + TTS) 2.77× faster total turn
4. "What is MicroPython. Be concise" + Piper TTS 50 tokens in 15.43 s decode (3.24 tok/s overall · 4.91 tok/s Sent. 1) · 10.9s first-token wait · Sent. 1 WAV plays @ 6.75s 43 tokens in 31.98 s decode (1.34 tok/s overall · 2.00 tok/s Sent. 1 avg) · 27.2s first-token wait · Sent. 1 TTS triggers @ 6.56s 2.42× faster decode · 2.49× faster first-token wait
Practical Maker Guidance — When to Use 1B Edge Models vs. Cloud AI for Arduino C++: Compact 1-billion-parameter quantized models (Gemma 3 1B Q4) are well suited for offline concept explanations, prose summaries, and spoken voice Q&A. However, on both the UNO Q and the 2017 MacBook Pro, the 1B model omitted pinMode() and void loop() when asked for a raw C++ blink sketch. When generating compilable microcontroller firmware, use VTM Studio's 1-click header toggle to switch to Cloud Mode (Google Gemini or Groq) or load a hardware-verified sketch from Code Mode → Science Mode Examples.
02 // MILLISECOND TELEMETRY CAPTURE

Interactive 43-Token UNO Q Throughput & Piper TTS Oscilloscope

Hover or click any of the 43 measured token points below (or click [ Replay 43-Token Stream ]) to inspect how llama-server and Piper ONNX share the 4-core QRB2210 processor across the 31.98-second run [1, 4, 5, 6]:

Captured Hardware Stream // Arduino UNO Q (4 GB · ABX00173) · Linux 6.16.7 aarch64
Gemma 3 1B Q4 Decode Throughput (tok/s) vs. Sentence-Boundary Piper ONNX Synthesis
3.5 2.6 1.8 0.9 0.0 THROUGHPUT (TOK/S) PHASE 1: PURE DECODE (2.00 TOK/S AVG) PHASE 2: PARALLEL PIPER ONNX TTS Sentence 1 Audio Synthesizing @ t=6.56s PHASE 3: POST-TTS RECOVERY (1.54 TOK/S AVG) Phase 1 Avg: 2.00 tok/s Phase 3 Avg: 1.54 tok/s Full Turn Avg: 1.34 tok/s T01 (0.0s) T14 (6.56s · "." TTS Trigger) T24 (19.34s · "Python") T34 (25.90s) T43 (31.98s) ACCUMULATED TOKEN INDEX (T01–T43) & WALL-CLOCK ELAPSED TIME (SECONDS)
[ACTIVE NODE] Token #24 ("Python") · Elapsed: 19.337s · Δ = 318 ms · Phase 3 Avg: 1.54 tok/s (1.34 tok/s Turn Avg)
Phase 3: Post-TTS Decode
[VTM-HOST STREAM]: Micro Python is a Python implementation designed for microcontrollers and embedded systems. It’s a compact, optimized version of Python, focusing on speed and efficiency, often used for real-time control and sensor data processing.
03 // ARCHITECTURAL POSITIONING

4-Way Architectural & Workflow Comparison

Makers, educators, and engineers choose different tools depending on whether they are running headless command-line scripts, official board containers, browser circuit simulators, or an all-in-one desktop and SBC studio. Below is a respectful side-by-side comparison of how four approaches serve the hardware community [1, 2, 3, 4]:

Architectural Dimension VTM Studio 2.2.0 Arduino App Lab Prof. Marcelo Rovai UNO Q Curriculum Cirkit Designer
Execution Topology Standalone on-device GUI (ARM64/x64 Electron + Python 3.12 + local llama-server + Piper ONNX) Hybrid (runs natively on UNO Q SBC or tethered/wireless via host PC) [1, 2] Headless CLI, Jupyter notebooks & Python/C++ scripts compiled on board [3] Web browser & desktop application (Windows, macOS, Linux)
Memory Discipline on 4 GB UNO Q Smart Auto-SBC Profile (512 MB V8 heap cap, /dev/shm RAM cache, detached inactive DOM views inside 3.58 GB RAM) Containerized Python/C++ Bricks (or 0 MB UI overhead when tethered to a host PC) [2] Lean headless C++/Python processes (maximizes free RAM for raw CLI models) [3] Designed for browser and desktop environments rather than standalone ARM64 SBC operation
AI & Voice Pipeline Local GGUF + click-to-talk faster-whisper STT + sentence-boundary Piper ONNX TTS + 1-click Gemini/Groq Cloud toggle Containerized AI Bricks (vision, audio, local LLM, Agent Mode) + Bridge RPC [2] Direct llama.cpp SLMs, local RAG, tool-calling & Edge Impulse .eim models [3] Cloud AI circuit and code assistant
Real-Time STM32U585 MCU Control & UART Isolation Deterministic STM32U585 C++ via arduino-cli, /dev/ttyHS1 & arduino-router (127.0.0.1:7500) while isolating reserved /dev/ttyMSM0 & /dev/ttyHS0 UARTs; native 50 Hz PWM, PCA9685, Dynamixel AX-12A, SSC-32 & 115200-baud loops (never timed by Python/LLM) Deterministic STM32U585 via containerized App Lab Bricks & Bridge RPC [1, 2] Manual /dev/ttyHS1, Bridge RPC, or serial scripting with custom C++ firmware [3] Virtual circuit simulation & desktop serial monitor
Tri-Engine Vision & 3.58 GB RAM Strategy Local HSV Lock color/centroid X/Y tracker (7 colors + AUTO) + Gemini Cloud Vision; Smart Auto-SBC Profile auto-gates MediaPipe COCO-80 on 4 GB SBCs to prevent OOM alongside llama-server & Piper TTS Local quantized neural vision/audio models (FOMO MobileNetV2, TFLite/GPU Bricks) without a local LLM competing for RAM [2] Edge Impulse .eim impulses, OpenCV/ONNX pipelines, or standalone VLMs manually budgeted by developer [3] Not applicable
Electrical Safety & Pin-Domain Guardrails Spec & Reference Modes map 1.8V QRB2210 MPU pins (JMISC/JCTL/JMEDIA) vs. 3.3V STM32U585 MCU headers and flag non-5V-tolerant A0 (PA4) & A1 (PA5) 3.3V ADC inputs Managed via official board documentation and container abstractions [1, 2] Developer-managed pin levels, voltage dividers, and datasheet lookups [3] Virtual component pinout and wiring guides
Circuit, Code & Cross-Board Portability Identical 2D breadboard layouts (.vtml/.psd/.svg/.png), Spec sync, Monaco IDE, 115200-baud Science Mode, Meter Mode (V/Ω/Continuity), 5/6-DoF Arm Control across UNO Q, Pi 4B, Uno R3/R4, ESP32, RP2040, macOS & Windows Purpose-built for Arduino UNO Q dual-processor C++/Python Bricks & Bridge API [2] Open-source UNO Q Python/C++ repositories, Bridge RPC & sensor/webcam I/O [3] Large virtual part library, breadboard wiring & circuit simulation
On-Device Model Quantization Built-in 3-Tab Model Forge (Convert local HF .safetensors -> Q4/Q8 GGUF -> Hot-Swap) 1-click cloud integration with Edge Impulse Studio [2] Manual CLI llama.cpp quantization & Edge Impulse training [3] Not applicable
Licensing & Access One-time purchase ($8.99 SBC .deb · $9.99–$39.99 Desktop · 2 devices/key · 0 subscriptions) Free official Arduino software [2] Free open-source academic textbook & GitHub repositories [3] Free & paid tiers available
04 // HONEST ENGINEERING TRADE-OFFS

Where Each Approach Shines

In embedded engineering, every architectural choice is a trade-off between raw headless compute headroom and integrated graphical convenience:

1. Official Hardware Integration

VTM Studio vs. Arduino App Lab

Arduino App Lab is the official, free standard for the UNO Q [1, 2], excelling when you want to dedicate the QRB2210 RAM budget to containerized neural vision/audio Bricks (such as Edge Impulse FOMO) or run tethered from a host PC. VTM Studio shares the exact same deterministic STM32U585 real-time execution philosophy—flashing C++ via arduino-cli and binding natively to /dev/ttyHS1 and arduino-router (127.0.0.1:7500) while isolating reserved /dev/ttyMSM0 and /dev/ttyHS0 UARTs—while keeping a local 1B GGUF LLM + Piper TTS resident in RAM alongside low-overhead HSV Lock color tracking, Gemini Cloud Vision, 1.8V/3.3V and non-5V A0/A1 pin guardrails, and cross-board continuity across UNO Q, Pi 4B, Uno R3/R4, ESP32, macOS, and Windows [1, 4].

2. Headless CLI vs. Full Desktop GUI

VTM Studio vs. Prof. Marcelo Rovai's Curriculum

Professor Marcelo Rovai's open-source UNIFEI coursework (Mjrovai/ARDUINO-UNO-Q) is an outstanding educational resource that demonstrates the bare-metal command-line ceiling of the UNO Q [3]. By skipping a desktop windowing interface and concurrent TTS process, a headless CLI workflow dedicates all CPU cores and free RAM directly to raw terminal inference. VTM Studio trades that headless headroom so builders can work inside a visual studio with live token telemetry, sentence-boundary Piper ONNX voice readback, 2D circuit layouts, and one-click Cloud/Edge AI switching without command-line friction [4, 5, 6].

3. Virtual Simulation vs. Physical I/O

VTM Studio vs. Cirkit Designer

Cirkit Designer excels at virtual circuit simulation and auto-wiring across a large component catalog before you wire physical parts on your desk. VTM Studio focuses on the live physical hardware loop once components are in your hands—combining 2D breadboard layout documentation (.vtml, .psd, .svg, .png) with offline local GGUF model execution, on-device quantization, real-time 115200-baud sensor gauges, and direct USB serial 5-DoF/6-DoF servo control with no recurring subscription [4].

05 // REPRODUCIBLE METHODOLOGY

Hardware Diagnostic Fingerprint

Every UNO Q metric on this page was parsed directly from VTM Studio's built-in diagnostic bundle exporter (/export_diagnostic_bundle), the X-Panel Inference Monitor log, and the HTML session transcript exporter across a 4-turn local Edge AI session (arithmetic, an 87-word short story, a 69-token C++ Arduino digitalWrite code snippet, and the 43-token MicroPython query) [4]:

  • • Board & SoC: Arduino UNO Q (4 GB, SKU ABX00173), Qualcomm Dragonwing QRB2210 (Quad-Core ARM Cortex-A53 @ 2.0 GHz) + STM32U585 MCU [1]
  • • Kernel & Runtime: Linux 6.16.7-g0dd6551ae96b #1 SMP PREEMPT aarch64 · Python 3.12.8
  • • Usable Linux RAM: 3.58 GB (Smart Auto-SBC Profile active: 512 MB V8 heap cap, /dev/shm RAM cache, detached inactive DOM views)
  • • Active Packs Loaded: maker, maker_pro, physical_ai_pro (All 3 tiers active)
  • • Telemetry Heartbeat: GET /system_stats HTTP/1.1 200 every 3.00 s (0 dropped requests, 7 ms HTML archive export)
Excerpt // Raw Diagnostic & Stream Log
{
  "product": "VTM Studio", "version": "2.2.0",
  "system": {
    "os": "Linux", "os_release": "6.16.7-g0dd6551ae96b",
    "architecture": "aarch64", "python_version": "3.12.8",
    "ram_total_gb": 3.58
  },
  "license": {
    "activated": true,
    "purchased_packs": ["maker", "maker_pro", "physical_ai_pro"]
  }
}
[17:21:41.191] Accumulated 1 tokens: Micro
[17:21:41.520] Accumulated 2 tokens: Micro Python (Δ=329ms · 3.04 tok/s)
[17:21:47.756] Accumulated 14 tokens: ...embedded systems. (Piper TTS Trigger @ 6.565s)
[17:22:00.210] Accumulated 23 tokens: ...optimized version of
[17:22:00.528] Accumulated 24 tokens: ...version of Python (Δ=318ms · 3.14 tok/s PEAK)
[17:22:13.173] Accumulated 43 tokens: ...sensor data processing. (31.982s total)
06 // VERIFIED DATASHEETS, REPOSITORIES & SPECIFICATIONS

References & Technical Citations

  1. Arduino SA. Arduino UNO Q (ABX00162 2 GB / ABX00173 4 GB) Datasheet & Hardware Documentation (Qualcomm Dragonwing QRB2210 Quad-Core ARM Cortex-A53 @ 2.0 GHz & STMicroelectronics STM32U585 MCU). https://docs.arduino.cc/hardware/uno-q/
  2. Arduino SA. Arduino App Lab Documentation (Dual-Processor C++/Python Environment, AI Bricks & Bridge RPC). https://docs.arduino.cc/software/app-lab/
  3. Rovai, M. J. (UNIFEI). Edge Machine Learning Systems Engineering Using Arduino UNO Q (Open-Source Curriculum & GitHub Repository). https://github.com/Mjrovai/ARDUINO-UNO-Q
  4. Padilla, T. VTM Studio 2.2.0 System Requirements, First-Party Hardware Telemetry Logs & Smart Auto-SBC Profile Guide. https://videotronicmaker.com/download/
  5. Gerganov, G. & GGML Contributors. llama.cpp & GGUF Model File Format Specification (Q4_K_M ~4.8 bits/weight and Q8_0 ~8.5 bits/weight Block Quantization). https://github.com/ggml-org/llama.cpp
  6. Hansen, M. & Open Home Foundation. Piper: Fast, Local ONNX Text-to-Speech Synthesis System. https://github.com/OHF-Voice/piper1-gpl
  7. Radford, A. et al. (OpenAI) & Klein, G. (SYSTRAN). Robust Speech Recognition via Large-Scale Weak Supervision (Whisper) & faster-whisper CTranslate2 INT8 Runtime. https://github.com/SYSTRAN/faster-whisper
  8. Google DeepMind. Gemma 3 Technical Report (arXiv:2503.19786) & Gemini API Multimodal Specification. https://arxiv.org/abs/2503.19786 · https://ai.google.dev/gemma/docs/core