Linux on Qualcomm SoCs has been a roller coaster, with hope often followed by disappointment, at least for the Snapdragon family. The company aims to change that with Qualcomm Linux 2.0 for Dragonwing IoT platforms, as announced on LinkedIn: With Qualcomm Linux 2.0, we’re shifting to an upstream-first, open development model that is unified and scalable across all Qualcomm Dragonwing IoT platforms. This means an upstream‑first model with a BSP that tracks mainline to minimize friction and enables you to make more predictable builds. Tune in to see our first-ever live demo, along with a lifecycle and release strategy, core architecture and Yocto changes, and practical migration paths from previous versions The video is embedded below, but will only be live on June 30. In the meantime, the description provides a few more details: If you’ve dealt with fragmented BSPs, platform-specific kernel forks, or painful bring‑up across Qualcomm SoCs, this […]

The post Qualcomm promises a major reset with upstream-first, Qualcomm Linux 2.0 for Dragonwing IoT platforms appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/06/19/qualcomm-promises-a-major-reset-with-upstream-first-qualcomm-linux-2-0-for-dragonwing-iot-platforms/

The post Qualcomm promises a major reset with upstream-first, Qualcomm Linux 2.0 for Dragonwing IoT platforms appeared first on IPv6.net.

Read more here: https://www.zdnet.com/article/sensecap-t1000-e-tracker-card-airtag-alternative-review/

The post This Bluetooth tracker uses LoRa mesh networks to find things – and I couldn’t believe the accuracy appeared first on IPv6.net.

When talking about large language models (LLMs), people usually imagine a general-purpose assistant: something that can answer questions about weather, politics, software, history, travel, cooking, electronics – and almost any other topic. The model is expected to know a little bit about everything, follow open-ended conversations, and respond to a very broad range of prompts. That’s the experience most of us are used to, since cloud-based AI tools have become so widespread.

Embedded systems work in a much more “narrow” world. A robot does not need to discuss politics, an inspection system does not need to suggest vacation destinations, and a maintenance assistant installed near a machine does not need to explain ancient history. The system needs to understand the device, the task, the possible commands, the local data, and the actions that are safe to suggest or execute. The goal is to give an edge device enough language intelligence to become more useful, more understandable, and more independent from the network.

This is the framework in which we can think about local LLMs on UNO Q: a practical platform to explore this idea because it brings together a Debian Linux environment and the Arduino^® hardware ecosystem. The Linux side can run local AI tools, command-line workflows, Python applications, web services, and inference runtimes. The Arduino side connects that intelligence to sensors, actuators, shields, Arduino^® Modulino nodes, and real-world signals. This combination makes it possible to experiment with language models not as isolated chatbots, but as part of real embedded workflows.

The most important question to consider is not how to force a large model to run, but what kind of useful intelligence can live close to the data, close to the device, and close to the physical action?

Step 1: choose the right model for your use case

The edge is where smaller, optimized models become interesting. On the cloud, a large general-purpose model makes sense because it is expected to answer almost anything. On the edge, a model that has been trained, fine-tuned, distilled, or quantized for a specific domain can be more practical. It carries less unnecessary weight, focuses on the type of language the device actually needs, and can be integrated into a controlled application flow.

For example, in robotics the interaction can often be reduced to a limited set of useful instructions: move forward, stop, inspect this object, return to base, report battery level, explain the last error, switch to manual mode. The model can help interpret natural language, but the system should still map that interpretation to a controlled set of valid commands. This makes the behavior easier to test, easier to validate, and easier to trust.

That narrower scope is one of the reasons local LLMs can make sense on embedded platforms.

Step 2: understand your memory and storage constraints

A large language model usually has many parameters, and every parameter represents data that must be stored, loaded, and processed during inference. Model weights are only part of the story. During generation, the runtime also needs working memory for the prompt, the intermediate computation, and the key-value cache used by transformer models to keep track of previous tokens. As the context grows, memory usage grows too.

A 1B-parameter model in 4-bit quantization (such as Llama 3.2 1B Q4) occupies roughly 600–700 MB on disk and requires around 1 GB of RAM at runtime, including the KV cache for a short context window. A 3B model at the same precision pushes past 2 GB. These are numbers that matter on a board with fixed memory and storage, where the model must coexist with the OS, the runtime, and the rest of the application.

Quantization is one of the techniques that makes this more realistic. Instead of storing model weights with high-precision numerical values, a quantized model uses lower-precision representations. This reduces memory usage and can make inference possible on hardware that would otherwise be too constrained. In practical terms, quantization helps move a model from “too large to run locally” towards “small enough to experiment with” – while accepting a trade-off in accuracy, fluency, or speed depending on the model and runtime.

Model distillation is another important concept. In simple terms, distillation is a training approach where a smaller model learns from a larger teacher model. The goal is to keep useful behavior while reducing inference cost and memory footprint. A distilled model will not have the full breadth of the teacher, but it can be much more suitable when the application needs a focused capability on-device.

This example of running local LLMs and VLMs on UNO Q with yzma expands the conversation beyond text chat and explores local LLM and VLM workflows using yzma and llama, pointing toward a wider class of edge AI experiments where language models can work together with images, local data, and device context.

Step 3: identify where a local LLM adds real value

Local LLMs become even more useful when they are combined with other edge workflows. OCR is a good example. A camera connected to an UNO Q may extract text from a label, display, document, or machine interface. A compact language model can then summarize that text, classify it, or turn it into a structured response. The model only needs to process the relevant context, which keeps the workflow lighter and more focused.

The same principle applies to an UNO Q that collects logs, sensor readings, error states, or system events. A local model can turn that information into a short human-readable summary directly on the device. For a technician, this can transform raw data into something immediately useful – a compact explanation of the current status or a short description of the last error condition.

Step 4: design the architecture and set your boundaries

One of the most practical ways to think about local LLMs on UNO Q is to treat the model as an occasional reasoning layer. It can be called when language understanding, summarization, or interpretation adds value. Fast control loops, continuous monitoring, and timing-critical actions remain better suited to deterministic software running on the appropriate side of the system.

When working with local LLMs on UNO Q, developers should take into consideration a few practical parameters. Memory usage comes first: the model must fit comfortably together with the runtime and the rest of the application. Response latency comes next: a model that runs may still feel too slow if the use case expects instant answers. Storage should also be planned carefully, because model files and dependencies can be large.

The best entry point is the Arduino Project Hub tutorial Local LLM AI Chatbot on UNO Q, which walks through installing a small LLM and running it offline. It is a useful starting point because it demonstrates the basic shape of a local LLM application

There is also a natural bridge toward local agents. Agentic workflows can move beyond a simple chat interface and start coordinating tools, files, scripts, and actions. On UNO Q, this direction is especially interesting when the agent is treated as an orchestrator on the Linux side. It can inspect logs, prepare files, call scripts, interact with local tools, or help drive development workflows, while the hardware-facing layer keeps direct control over physical I/O.

This kind of setup requires clear boundaries. Giving an agent access to tools means giving it the ability to change things, so the environment should be designed carefully. A dedicated board can be a useful sandbox for this type of experimentation, with limited credentials, limited data access, and a specific set of allowed tools. This makes it possible to explore agentic workflows while keeping the system understandable and controlled.

If you prefer a familiar developer workflow, Installing Ollama on Arduino UNO Q covers a practical detail that matters a lot on embedded Linux systems: how to efficiently manage the resources available on the UNO Q to get the most out of it.

Step 5: run it, measure it, iterate

Pick one model, run it on the board, and pay attention to memory usage and response time for your specific prompt. That real-world data will tell you more than any benchmark – and it will give you a much clearer picture of where a local LLM fits in your next embedded project.

Local LLMs on UNO Q always balance power, cost, size, latency, privacy, reliability, and connectivity. The most interesting question is how much useful intelligence can be placed close to the data, the hardware, and the user. Because edge AI is not about more power. It’s about smarter choices. With the right model, the right architecture, and the flexibility of UNO Q, you can test local AI where it matters most: on real hardware, in real projects.

Start building with UNO Q and bring your AI ideas closer to the real world.

UNO Q is available to order from DigiKey, Farnell,Mouser, Newark, RS Components, and Robu.in; along with our other authorized distributors and resellers.

Arduino and UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Running local LLMs on the Arduino® UNO™ Q board: a practical guide appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/06/18/running-local-llms-on-the-arduino-uno-q-board-a-practical-guide/

The post Running local LLMs on the Arduino® UNO™ Q board: a practical guide appeared first on IPv6.net.

Read more here: https://www.zdnet.com/article/how-i-block-ads-with-cheap-raspberry-pi-alternative/

The post I programmed a $7 ESP32-S3 board to block all computer’s web ads – and it took just minutes appeared first on IPv6.net.

Read more here: https://www.zdnet.com/article/how-to-block-ads-with-cheap-raspberry-pi-alternative/

The post How I block ads with a $7 Raspberry Pi alternative – it’s easy appeared first on IPv6.net.

Read more here: https://www.bleepingcomputer.com/news/security/indias-telegram-ban-hit-the-uae-too-heres-how-to-get-around-it/

The post India’s Telegram ban hit the UAE too. Here’s how to get around it appeared first on IPv6.net.

SCINTIX P4 is an ESP32-P4 RISC-V Compute Module with an ESP32-C6 for wireless connectivity that’s compatible with Raspberry Pi CM4/CM5 carrier boards, at least partially. It should be the first MCU-based system-on-module in Raspberry Pi CM4/CM5 form factor, and RELOC says the SCINTIX P4 gives access to displays, cameras, Ethernet, USB, and all the peripherals the ESP32-P4 exposes when connected to a carrier board. It can also be programmed in standalone mode through its built-in USB Type-C port. SCINTIX P4 (RM-CMP4) specifications: SoC – Espressif Systems ESP32-P4NRW32X  CPU Dual-core RISC-V @ 400 MHz with AI instruction extensions and single-precision FPU Single-core RISC-V LP (low-power) MCU @ up to 40 MHz GPU – 2D Pixel Processing Accelerator (PPA) VPU – H.264 and JPEG codecs support Memory – 768 KB HP L2MEM, 32 KB LP SRAM, 8 KB TCM, 32MB PSRAM Storage – 128 KB HP ROM, 16 KB LP ROM Storage […]

The post SCINTIX P4 ESP32-P4 Compute Module works with (some) Raspberry Pi CM4/CM5 carrier boards (Crowdfunding) appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/06/17/scintix-p4-esp32-p4-compute-module-raspberry-pi-cm4-cm5-carrier-boards/

The post SCINTIX P4 ESP32-P4 Compute Module works with (some) Raspberry Pi CM4/CM5 carrier boards (Crowdfunding) appeared first on IPv6.net.

Read more here: https://www.zdnet.com/article/sensecap-t1000-e-tracker-card-airtag-alternative-review/

The post I tested a Bluetooth tracker that leverages LoRa mesh networks to find things – and it’s so accurate appeared first on IPv6.net.

All airplane engines have the same basic goal, which is to create forward thrust. But the modern airline industry is an exercise in maximizing efficiency and the most efficient option for large aircraft tends to be a turbofan jet engine. Most of us never get to see those up close, but you can 3D print this wildly complex and partially functional turbofan jet engine model to see how they work.

This isn’t an exact scale replica of any specific engine, but it was heavily inspired by the CFM56-5 series of engines used in Airbus A320 jets. Referencing that actual engine design, CADLY’s Adrian Barsotti modeled this engine to be a good compromise between accuracy and 3D printing practicality. There are even two variations: a complete engine and just the turbofan assembly on a stand.

The complete engine has panels you can open up to see the inner workings, while the turbofan assembly gives you an unobstructed view of the good stuff all the time.

Both models are entirely 3D-printable, with the exception of some hardware, fasteners, and electronic components. Those electronic components bring the engine to life, so you can spin up the fans and actuate the reverse thrust flaps.

Those work thanks to an Arduino Nano board, which controls the main DC motor through an L298N dual H-bridge driver and opens the flaps with servo motors. Power comes in at 5V and there is a DC-to-DC converter for the 12V components. Wago connectors make the wiring easy and tidy.

If you want to print this model yourself, you can find all of the files over on Printables. 

The post You can 3D print this amazingly complex turbofan jet engine model appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/06/15/you-can-3d-print-this-amazingly-complex-turbofan-jet-engine-model/

The post You can 3D print this amazingly complex turbofan jet engine model appeared first on IPv6.net.

Today, we’re excited to share that key members of the team at Ensemble AI are joining Cloudflare to help accelerate our work in AI infrastructure and make it easier for developers to run powerful AI models efficiently at scale.

Ensemble AI, founded in 2023 in San Francisco, has spent the last few years focused on one of the most important challenges in AI: making large models faster, smaller, and more cost-effective to serve, without sacrificing quality. The team has developed new approaches to model compression and efficient inference that are designed to reduce the memory, compute, and deployment overhead of large language models and multimodal architectures.

As AI becomes a core part of how developers build applications, the economics of inference matter more than ever. Models are getting larger; workloads are becoming more dynamic. And customers increasingly expect AI to be available everywhere: globally distributed, fast, reliable, and affordable. Bringing the Ensemble AI team into Cloudflare strengthens our ability to make that possible.

The team at Ensemble AI has focused on preserving the structure inside modern AI models while reducing the cost of running them. Instead of treating model efficiency as only a quantization or hardware problem, Ensemble has explored new model building blocks that can make neural networks more compact and efficient at the architectural level.

A core part of this work is NdLinear, a drop-in replacement for standard linear layers in transformer models that operates directly on multidimensional activations rather than flattening structure away. This enables models to preserve meaningful axes, such as heads, channels, spatial dimensions, or other structured representations, while reducing parameter count and compute. Ensemble has also developed NdLinear-LoRA, an efficient adaptation method designed to reduce the trainable parameters required for fine-tuning large models.

These approaches complement other efficiency techniques, including quantization and vector quantization. Together, they point toward a future where developers can run capable AI models with substantially lower memory, compute, and cost requirements.

Cloudflare Workers AI gives developers access to serverless GPU-powered inference on Cloudflare’s global network. As developers build more AI-native applications, the ability to serve models efficiently becomes a critical part of the platform.

Inference cost is one of the biggest barriers to scaling AI applications. Every improvement in model size, memory footprint, throughput, and GPU utilization can make AI more accessible to developers and more economical for customers. This is especially important as AI workloads expand beyond simple text generation into agents, multimodal models, personalization, fine-tuning, retrieval, and reinforcement learning.

We are deepening our investment in the core machine learning capabilities needed to make Workers AI faster, more flexible, and more cost-efficient. This builds on top of our existing work on improving model efficiency, including our inference engine Infire, tensor compression techniques like Unweight, and our platform for running extra large language models. The team will focus on improving the economics of serving large language models and other advanced AI architectures, with an emphasis on model efficiency, GPU utilization, and scalable deployment.

AI infrastructure is entering a new phase. Developers no longer need only access to models; they need infrastructure that can run models reliably, affordably, and close to users. They need the ability to experiment with different model sizes, fine-tuning approaches, and deployment patterns without being blocked by cost or operational complexity.

Cloudflare is uniquely positioned to help solve this. Our global network, developer platform, and serverless architecture give us the foundation to bring AI closer to where applications already run. The Workers AI Machine Learning Engineering team will help us improve the efficiency layer underneath that experience.

By combining Cloudflare’s global infrastructure with Ensemble’s work in model compression and efficient architectures, we can continue building a platform where developers can deploy AI applications with lower cost, better performance, and less operational overhead.

Together, we will continue building the infrastructure needed to make AI more efficient, accessible, and useful for developers everywhere. Our goal is simple: help developers run powerful AI workloads at global scale while improving the economics of inference across the Cloudflare platform. If you want to join us in our mission, check out our careers page.

Read more here: https://blog.cloudflare.com/ensemble-ai-talent-joins-cloudflare/

The post Growing the Cloudflare AI team with talent from Ensemble AI appeared first on IPv6.net.