Snapdragon

Snapdragon is Qualcomm's brand for its system-on-chip (SoC) family, combining processing, graphics, neural processing, modem, and radio connectivity on a single piece of silicon. From the Snapdragon 8 Elite powering flagship Android smartphones to the Snapdragon X Elite running Windows Copilot+ PCs, the platform targets the full spectrum of connected devices. Snapdragon is the primary hardware platform for on-device AI in consumer electronics, with the Hexagon NPU achieving up to 100 TOPS on the latest generation.

General
Developer	Qualcomm
Type	System-on-Chip Platform
License	Proprietary (silicon); developer tools include open-source components
GitHub	qualcomm/ai-hub-models
Documentation	Qualcomm AI Hub Docs
AI Hub	aihub.qualcomm.com

Core Features

Hexagon NPU — dedicated neural processing unit optimized for AI inference; achieves 40 TOPS (8 Gen 3) to 100 TOPS (8 Elite); ranked #1 on MLPerf Inference v4.0 mobile benchmark.
Heterogeneous AI Engine — workloads dynamically distributed across Hexagon NPU, Adreno GPU, and Oryon/Kryo CPU for optimal power efficiency.
Qualcomm AI Hub — cloud platform with 175+ pre-optimized models and remote profiling on 50+ real Snapdragon devices; install with pip install qai_hub_models.
Multi-precision support — FP32, FP16, INT16, and INT8 inference; enables quantized LLM deployment on mobile hardware.
On-device LLM execution — validated with Llama, Mistral, Qwen3, IBM Granite, and Stable Diffusion variants via AI Hub.
Sensing Hub — ultra-low-power always-on processor for continuous sensor monitoring without waking the main cores.

Snapdragon Platform Variants

Variant	Segment	NPU Performance	Notable Devices
Snapdragon 8 Elite	Flagship mobile (2024-2025)	100 TOPS	Samsung Galaxy S25 series
Snapdragon 8 Gen 3	Flagship mobile (2023-2024)	~40 TOPS	Samsung Galaxy S24 series
Snapdragon X Elite	Windows laptops / Copilot+ PC	45 TOPS	Microsoft Surface Laptop
Snapdragon X2 Elite	Windows laptops (2025)	80 TOPS	Next-gen Copilot+ PCs
Snapdragon AR2	AR glasses	Ultra-low power	Various XR wearables

Tools and Resources

Qualcomm AI Hub — aihub.qualcomm.com — browse pre-optimized models, run cloud profiling sessions, and download deployment artifacts.
AI Hub Models (GitHub) — github.com/qualcomm/ai-hub-models — open-source Python library (BSD-3-Clause) with 200+ model recipes.
AI Engine Direct SDK (QNN) — low-level SDK for building applications directly targeting the Hexagon NPU.
AI Model Efficiency Toolkit (AIMET) — quantization, pruning, and compression tools for edge-friendly model preparation.
Snapdragon Neural Processing Engine (SNPE) — runtime that converts ONNX and TensorFlow models to Snapdragon-native format.
Qualcomm Device Cloud — remote access to physical Snapdragon hardware for testing without owning devices.
ONNX Runtime Execution Provider — plugin for running ONNX models with Hexagon NPU acceleration.
Developer Discord — discord.com/invite/qualcommdevelopernetwork.

Ecosystem and Integrations

Verified integrations with Amazon SageMaker, Hugging Face, Roboflow, Dataloop, EyePop.ai, and NOTA AI for model preparation and deployment.
ExecuTorch (Meta/PyTorch) includes a stable Qualcomm AI Engine backend for deploying PyTorch models directly to the Hexagon NPU.
Llama 3.2 1B and 3B models from Meta were co-optimized for Snapdragon via QAT+LoRA quantization, achieving over 350 tokens/s prefill on Galaxy S24+.
Copilot+ PCs built on Snapdragon X Elite are Windows-native AI development targets, with NPU exposure via DirectML and QNN.

Start building with the Qualcomm AI Hub quickstart or clone the ai-hub-models repository and run pip install qai_hub_models to access the full model library.

Code2Edge: Deployment with Proof

Porting a PyTorch model to a microcontroller sounds like a model problem, but it's really a pipeline problem. A keyword-spotting model needs audio resampled, windowed, FFT'd, run through a Mel filterbank, log-compressed, and normalized before it ever reaches the network — and the constants controlling each step (window size, FFT convention, epsilon values) are usually scattered across config files nobody rereads. Get one of them wrong in the C rewrite and the device still boots fine; it just quietly predicts the wrong thing, with no black-box "pass/fail" test telling you why. Code2Edge solves this with stage-wise differential parity instead of black-box testing. The same audio corpus runs through both the Python reference pipeline and the generated C pipeline, and every intermediate tensor is compared — max/mean absolute error, cosine similarity, and eventually prediction agreement. If a stage drifts past tolerance, the system flags exactly which stage and offers a deterministic hint (e.g., "shape mismatch at framing — check hop length"), so debugging starts from evidence instead of guesswork. Bob drives this as an orchestrator, not a black-box code generator. An MCP server gives it five hardware-aware tools (profiling the model, inspecting the pipeline, checking the target, running parity tests, benchmarking) plus workflow tools for starting runs and gating steps. Bob follows a fixed sequence: analyze the repo, produce an Edge Readiness Report, pause for a human APPROVE/REJECT, generate code, run a host parity gate (with a 3-attempt repair loop before escalating to a human), build for the MCU, run a device parity gate, benchmark on real silicon, and open a pull request. The target users are embedded/ML engineers who need confidence that a ported pipeline behaves identically to its source model — not just that it compiles. The project is grounded in a real trained workload: a 119,372-parameter DS-CNN for 12-class keyword spotting (96.65% test accuracy), deployed to an STM32U585 (Cortex-M33) on an Arduino UNO Q. What makes this different is the discipline around honesty: every reported number is explicitly labeled real (measured from an artifact) or mock (a placeholder for an unavailable dependency), and the two are never mixed. Host-side parity is fully real and passing across 500 samples and 4 pipeline stages. Physical benchmarking is real and passing on actual silicon (50/50 correct inferences). Device-side parity is real but currently limited to a single fixture rather than the full corpus — an openly disclosed gap, with a hardware-validation guide checked in to finish the job.

Team Xcel- VisionKnob

VisionKnob is an interactive AI-powered image understanding system that combines physical hardware controls with computer vision and multimodal AI. The idea behind the project is to make image analysis more intuitive, private, and engaging by allowing users to interact with AI through a physical knob instead of relying only on a keyboard or mouse. The system uses an Arduino UNO Q and Modulino hardware as the physical interface. Users can turn or press the knob to navigate through images, select an image, and interact with the AI assistant. A Streamlit-based interface displays the selected image and allows the user to ask questions about what the image contains. VisionKnob uses a Gemma vision model to analyze the selected image and generate natural-language responses. For example, a user can ask the system to describe an image, identify important objects, explain what is happening in a scene, or answer specific questions about visual details. One of the main goals of VisionKnob is to explore how physical computing and generative AI can work together to create more natural human-computer interactions. Instead of AI existing only as a chatbot, VisionKnob connects AI with real-world hardware controls, making the interaction more tangible and accessible. The project also focuses on local and privacy-conscious AI processing. By using models that can run locally, sensitive images do not necessarily need to be uploaded to external cloud services. This makes VisionKnob useful for applications where privacy, offline access, or low-latency responses are important. VisionKnob demonstrates how multimodal AI, embedded hardware, and modern user interfaces can be combined into a practical system for visual exploration, education, accessibility, research, and future smart-device applications.

Atheon: From Pencil to Pixel

Atheon: From Pencil to Pixel is a smart handwriting-tracking system designed to capture the motion of a pencil directly from the writing instrument itself. A miniature global-shutter camera mounted near the pencil tip observes the paper surface while a synchronized LED strobe freezes motion during each exposure. Computer-vision algorithms track the changing paper texture between frames to estimate the pencil’s movement across the page, allowing physical handwriting to be reconstructed as a digital path. The system is built around a Raspberry Pi Zero 2 W, an OV9281 global-shutter camera, custom strobe electronics, and a compact battery-powered design intended to fit onto a handheld writing device. Unlike systems that require special paper, a tablet surface, or an external overhead camera, Atheon is intended to work directly on ordinary paper while preserving the natural experience of writing with a pencil. The project focuses on solving the challenges of motion blur, changing pencil angle, perspective distortion, limited working distance, and reliable visual tracking during fast handwriting.

Local AI Secretary on Snapdragon X Elite

We built a fully local AI Secretary for Snapdragon X Elite and optimized the complete inference path rather than chasing raw tokens per second. The system turns natural-language requests into deterministic structured actions such as list_files, read_file, search_files, move_file, and clarify, while keeping inference on-device. Our implementation evaluates multiple execution paths for Qwen3-0.6B: llama.cpp on CPU, llama.cpp on HTP, and Qualcomm’s native QAIRT/GenieX path on the Hexagon NPU. We created a frozen 50-case Secretary benchmark and measure end-to-end task latency, TTFT, prefill and decode throughput, correctness, memory, and energy per completed task. This lets us compare backends on the metric that matters to a real assistant: correct task completion, not synthetic throughput alone. We also designed the system around three operating modes—FAST, BALANCED, and EFFICIENT—and investigated task-aware routing so deterministic requests can bypass the LLM and harder requests can use the appropriate model/runtime. For structured reliability, we focused on constrained outputs, short tool-call generation, and deterministic scoring. The project demonstrates a practical model-to-device optimization workflow on Snapdragon X Elite: benchmark, profile, compare CPU/HTP/NPU execution, preserve correctness, and select the best path for each workload.

MapLLM

Digital maps are great for navigation but nearly useless for exploration if you're blind: a screen reader gives you a list, never a layout. Tactile maps give real spatial layout under your fingers, but a sheet only fits a dozen braille labels — no store names, distances, hours, or "what is this?" MapIO keeps the cheap embossed sheet and moves all the information into audio. A camera looks down at the map; SIFT homography locks the sheet and MediaPipe tracks your index fingertip, which becomes your avatar on a street-and-POI graph. Wherever you touch, you hear what's there. The audio layer is unbounded, so density is limited by curiosity, not emboss space. For open-ended questions ("what's the closest coffee, and how far from here?") MapIO uses Gemma 4 served locally by Qualcomm AI Hub GenieX on the Snapdragon X Elite NPU. The model never guesses distances or routes: it calls tools on the map graph (get_distance, nearby POIs, guide_to_destination) and speaks deterministic answers. Everything runs on-premises; nothing leaves the LAN. The Qualcomm angle is two chips, two roles. The X Elite is the room's brain: one local LLM and speech server shared by every map. The Arduino UNO Q (QRB2210) is a sub-$60 map station that runs the whole perception loop on-device — SIFT, hand tracking, graph lookup, TTS — and streams speech straight to a speaker over Bluetooth. Plug in, it boots, it says "Map detected." A laptop alone works, and that's a supported deployment. But a board per map is what makes a museum floor or classroom practical: N cheap stations, one shared server, touch feedback that never crosses the network. Next: speech-to-text on the UNO Q itself, and unified Q&A that follows a visitor from map to map.

Edge Guard

Edge-Guard is a policy-driven AI routing system designed for edge intelligence workloads that need to balance performance, privacy, and reliability. Instead of sending every inference request to a single destination, it evaluates runtime conditions and policy constraints to decide whether the request should run locally on the edge, fall back to the cloud, or degrade safely when cloud use is not permitted. The system considers factors such as local latency, execution success, structured output validity, and privacy requirements before choosing the best path. It also provides transparent decision telemetry, benchmarking across routing strategies, and an interactive dashboard for testing different scenarios. In short, Edge-Guard helps organizations deploy AI at the edge with safer fallback behavior, better control over data movement, and clearer policy-based decision making.