标签：#Hardware

New Delhi announced a $6.5 billion smartphone manufacturing program and a $13.3 billion semiconductor push to deepen India's electronics supply chain.

Someone has to bundle all the wires that go into rockets, missiles, and satellites.

Look inside almost any modern connected device -- a smartphone, a smartwatch, a Wi-Fi thermostat, a battery-powered sensor node -- and you will find a processor core designed by ARM. It is one of the most successful engineering ideas in computing history. And here is the strange part: ARM has never manufactured a single one of those chips. It does not own a factory. It sells blueprints. A three-person project in Cambridge The story starts at Acorn Computers in Cambridge, England, in the early 1980s. Acorn had built the BBC Micro, a hugely popular educational computer in the UK, and it needed a faster processor for its next machine. The commercial chips available at the time were disappointing, so a tiny team decided to design their own. The acronym everyone knows today originally stood for Acorn RISC Machine . Sophie Wilson designed the instruction set and wrote the simulator; Steve Furber led the physical chip design. RISC -- Reduced Instruction Set Computing -- was the key bet. Instead of piling on complex instructions, they kept the instruction set small and simple, which made the chip easier to build, cheaper, and remarkably power-efficient. The first silicon, the ARM1, was fabricated by VLSI Technology and delivered to Acorn on 26 April 1985. When the team powered it on, it simply worked -- first try. For anyone who has designed hardware, that is almost unheard of; new processors normally need several rounds of revisions to shake out design errors. A famous piece of Acorn lore is that the early ARM chips drew so little current they could keep running on leakage alone after the power was disconnected. From a British computer to the whole world Acorn the computer company faded, but the processor design did not. In 1990 the ARM team was spun out into a separate joint venture, and the acronym was quietly re-expanded to Advanced RISC Machines . The new company made a decision that defined its future: it would not build chips. It would license the designs and let oth

A product idea from RayTally's daily scan of public signals. The idea One-liner: Helps first-time PCB designers find manufacturing and assembly problems on the board before they place an order. Concept: A desktop preflight tool helps first-time PCB designers find contradictions among their manufacturing files before payment. Users drag in Gerber files, a bill of materials, and placement coordinates. The first screen highlights high-risk locations such as board outlines, hole sizes, package orientation, and missing components. Clicking an issue locates the specific pad on the board and shows the design value beside the fabricator's rule. The tool also simulates panelization and the board's appearance after component placement, exposing problems such as insufficient connector overhang and component collisions before they happen. It does not require beginners to read an entire manufacturing standard; it focuses each check on the changes needed for the current order. Why now On July 11, 2026, a first-time board designer publicly documented the full process from designing in KiCad and exporting Gerber and drill files with default settings to sending them to a fabricator and assembling the board by hand. Before powering it on, he still put the odds of a first successful result at "fifty-fifty." At the July 13, 2026, 09:46 UTC capture, the experience had an observed score of 111 and 45 comments on Hacker News. KiCad already provides baseline capabilities including DRC, Gerber viewing, 3D viewing, and manufacturing-file output. Consolidating these scattered steps into one order-level preflight directly addresses the question beginners face before payment: what exactly should they check? Signal Hacker News "Designing and assembling my first PCB" (approximately 111 points and 45 comments, observed July 13, 2026, 09:46 UTC). RayTally scans public signals daily for product ideas worth building. Browse the source page and more product ideas .

The RingConn 3 actually looks like real jewelry, not a wearable -- but its fitness tracking and headache detection features are disappointing.

Kid-friendly tech company Pinwheel announced the launch of a new landline phone designed to let children stay connected without the distractions of a smartphone.

The AI hardware landscape has shifted significantly in 2026, with NVIDIA, AMD, and Intel all competing for developers who need GPUs capable of running local large language models and AI inference workloads. Choosing the right GPU for AI workloads requires looking beyond marketing numbers and focusing on the specifications that actually affect real-world performance. Memory capacity, memory bandwidth, and software ecosystem maturity consistently matter more than theoretical compute peaks when running transformer models locally. This comparison covers the most relevant workstation and prosumer GPUs available in mid-2026, including NVIDIA's Blackwell architecture (RTX 50-series), AMD's Radeon AI Pro R9700, and Intel's Arc Pro B70. The goal is to provide a practical reference for developers deciding which hardware best fits their model sizes, software stack, and budget constraints. Which GPU specifications matter for AI workloads Marketing materials from GPU vendors emphasise AI TOPS and tensor performance, but these metrics rarely tell the complete story for local inference. The specifications below are ranked by their actual impact on running large language models. VRAM capacity VRAM is typically the first limiting factor when running LLMs locally. A model cannot execute entirely on the GPU if it does not fit into available memory. Once model weights spill into system RAM, inference performance drops dramatically. Approximate VRAM requirements for common model sizes: Model Size Recommended VRAM 7B 8-12 GB 14B 16 GB 32B 24-32 GB 70B 48-64 GB 120B+ Multiple GPUs For most homelab users, moving from 16 GB to 32 GB of VRAM provides a substantially larger practical benefit than increasing raw compute performance. A 32 GB GPU capable of running an entire model will often outperform a theoretically faster 16 GB GPU forced to offload tensors into system memory. Memory bandwidth Memory bandwidth determines how quickly model weights can be streamed into compute units. Large tran

Ask most people to name the chip that started modern electronics and they will say the microprocessor. But there is a quieter hero inside almost everything you own that beeps, blinks, or connects to the internet: the microcontroller. And the first one you could actually buy shipped in 1974 as the Texas Instruments TMS1000. Microprocessor vs. microcontroller The distinction matters. A microprocessor, like Intel's famous 4004, is just the processing core. To build anything useful with it you still have to wire up separate memory chips, input/output controllers, and support logic on a circuit board. A microcontroller collapses all of that onto a single piece of silicon: the CPU, the ROM that holds your program, the RAM that holds your data, and the I/O pins that talk to the outside world, all in one package. That is exactly what the TMS1000 did. Designed by Texas Instruments engineers Gary Boone and Michael Cochran, it was a 4-bit device using a Harvard architecture, meaning it kept program memory and data memory in separate spaces so it could fetch an instruction and read data at the same time. One chip in, one chip out, and you had a complete tiny computer dedicated to a single job. Cheap enough to put in everything The genius of the TMS1000 was not raw power, it was economics. In 1974 you could buy the chips in volume for around two dollars each. By 1979, Texas Instruments was selling roughly 26 million of them every year. That price point changed what engineers could build. Suddenly it made sense to drop a small, programmable brain into products that never would have justified a full computer. You have almost certainly held one. The TMS1000 family ran the Speak & Spell, the Big Trak programmable toy vehicle, and the electronic memory game Simon, along with countless calculators, microwave ovens, and appliances. Each one was doing the same fundamental thing an IoT node does today: read some inputs, run a fixed program, drive some outputs. Why this still matters for

Last weekend’s brutal NYC heat wave had me craving a frozen drink almost every afternoon. Normally, that would mean sweating through a walk to 7-Eleven for a slurpee. This time, though, I stayed home and put the new Ninja Slushi Twist to the test. Ninja’s latest slushie machine builds on the popularity of the original […]

Linux 7.2 Improves Multi-GPU Displays, M3 Support, Mesa Rusticl Defaults Arm Mali Today's Highlights This week's hardware and driver news highlights include critical Linux 7.2 kernel updates for multi-GPU display detection and initial support for Apple M3 Pro/Max/Ultra SoCs. Additionally, Mesa's Rusticl OpenCL implementation now defaults to enabling Arm Mali Panfrost driver support, simplifying GPGPU access on embedded devices. Linux 7.2-rc3 Improves Multi-GPU Display Detection (Phoronix) Source: https://www.phoronix.com/news/Linux-7.3-rc3-Multi-GPU-Fix This update for the Linux 7.2-rc3 kernel targets a persistent issue within multi-GPU setups on x86_64 systems: inconsistent display detection. The patch specifically addresses scenarios where certain graphics cards, particularly in configurations mixing integrated and discrete GPUs or multiple discrete cards, would fail to initialize displays correctly or report their presence erratically to the operating system. This is a crucial fix for users and developers deploying workstations with diverse GPU hardware, ensuring more reliable and stable display outputs without manual configuration workarounds. The improvement lies in refining the kernel's ability to probe and correctly identify active display outputs across various GPU architectures. It directly impacts system boot times and user experience by reducing potential black screens or incorrect display layouts. For enterprise and professional users relying on multiple monitors or specific GPU setups for tasks like rendering or scientific computing, this kernel patch is a significant quality-of-life enhancement, removing a long-standing friction point in Linux graphics stack stability. This contributes to the broader goal of making Linux a more robust platform for high-end graphics and compute workstations. Comment: This is a welcome fix for anyone who's wrestled with inconsistent display outputs on multi-GPU Linux machines; it often means less time debugging Xorg conf

If you have ever wired a sensor to a Raspberry Pi or run your first Python script on one, you have used a device whose name hides two small jokes and one very deliberate design decision. Why is it called the Raspberry Pi? The short answer: "Raspberry" is a nod to a decades-old tradition of naming computers after fruit, and "Pi" is short for Python, the programming language the board was originally built to run. Both halves say something about where the machine came from, and why it went on to become a staple of IoT and embedded development. The fruit tradition behind "Raspberry" The "Raspberry" is not random. In the early decades of personal computing, a surprising number of companies named themselves after fruit. Apple is the obvious one, but there was also Acorn Computers (the British firm whose ARM architecture now sits inside nearly every phone and microcontroller on Earth), Apricot Computers, and Tangerine. When Eben Upton and his collaborators at the University of Cambridge set out to build a cheap computer to teach kids to code, choosing a fruit name placed the project squarely in that lineage. Upton has also cheerfully admitted the name is a bit of a pun, a wink at "blowing a raspberry" and at raspberry pie the dessert. Why "Pi" stands for Python The "Pi" is the part that reveals the machine's original purpose. As Upton has explained in interviews, the plan was to produce a computer that could really only run one thing well: Python. So the "Pi" in the name is a compressed reference to Python . It doubles neatly as a nerdy nod to the mathematical constant, but Python was the driving idea. That original intent matters because it explains the board's whole philosophy. The Raspberry Pi was never meant to be a powerhouse. It was meant to be cheap enough that a student could own one, simple enough that a beginner could learn on it, and open enough that it ran a full Linux operating system with Python ready to go. During development the design grew more capable tha

I game in a room that warms up fast. I could see CPU usage in Task Manager and watts in HWiNFO if I went looking. What I actually wanted was simpler: How much heat is this machine putting into the air right now? Not in a spreadsheet. In plain language I could glance at while the PC was running. The gap Lots of tools show watts and temperatures . Almost none answer room heat : BTU per hour Heat accumulated over a session Plain context like "about a quarter of a space heater" With ambient temp: still-air rise or rough exhaust CFM The conversion is straightforward ( BTU/hr ≈ watts × 3.412 ), but I didn't want to do it in my head every time. So I built HeatLens — a small desktop widget built around room heat, not raw sensor dumps. What HeatLens shows Total wattage — what the PC is drawing now Heat dissipation — BTU/hr or kW Session heat — BTU or kWh since launch Max temperature — hottest live sensor Trend graphs — watts, heat, and temp over time CFM estimate — with ambient temp: rough exhaust airflow for a +10 °F rise Still-air rise — how fast a reference room would warm with no ventilation Estimated power is labeled separately from measured sensors. Where the data comes from LibreHardwareMonitor / Open Hardware Monitor (HTTP + WMI on Windows) nvidia-smi for NVIDIA GPUs Linux RAPL / hwmon when exposed by the kernel Labeled fallbacks when direct power sensors aren't available On Windows, best results: LibreHardwareMonitor with Remote Web Server on port 8085 . What it is not HeatLens is not a replacement for a Kill-A-Watt at the wall. Software usually can't see monitor power, full PSU loss, or every platform rail. A plug-in meter is still the most accurate whole-system reading. HeatLens is for context : "~400 W gaming → ~1,400 BTU/hr into the room" Session heat over an hour or two Rough CFM / still-air numbers as sanity checks — not duct design Things I learned building it Sensor coverage is messy. Different backends, missing rails, and estimates that need clear labeling.

Every camera-equipped connected device you build today, from a smart doorbell to an ESP32-CAM streaming frames over Wi-Fi to a factory machine-vision rig, is a descendant of one clunky, toaster-sized prototype: the first digital camera , built at Eastman Kodak in December 1975. It weighed about 8 pounds, took 23 seconds to capture a single 0.01-megapixel black-and-white image, and recorded that image to a cassette tape. It looked like a science-fair project, but it proved a radical idea that underpins the entire IoT sensing industry: an image could be captured, digitized, and stored as data with no film at all. An engineer, a side project, and a CCD The camera was built by a 24-year-old Kodak engineer named Steven Sasson . His manager had handed him a loose assignment: could the newly invented charge-coupled device (CCD) image sensor be used to build a camera with no moving film? The CCD, developed at Bell Labs in 1969, converts light falling on an array of tiny capacitors into electrical charge, pixel by pixel. Sasson took a Fairchild 100-by-100-pixel CCD, bolted it to a lens from a Super 8 movie camera, added a digitizer, and wired the output to a portable cassette recorder. The result captured just 0.01 megapixels, a grid of 10,000 pixels. To view a photo, Sasson's team built a custom playback rig that read the tape and painted the image onto a television screen. That first image, a Kodak lab technician, took 23 seconds to write to tape and several more to display. Crude, yes, but it was the first fully electronic, filmless photograph. Why Kodak shelved the future Here is the twist that every embedded engineer should remember. Kodak owned the patent on the first digital camera, but the company made its money selling film, chemicals, and photo paper. Executives saw a filmless camera as a threat to that business, so the project was quietly set aside. Kodak did file the patent in 1978 and collected licensing revenue for decades, but it never led the digital transiti

The iPhone maker claims OpenAI encouraged poached employees to bring over confidential presentations, secret prototypes, and key supplier details.

The AI chip boom just produced its biggest Wall Street moment yet. Now SK Hynix and Samsung are being asked to build U.S. factories.

Dumb Co sells flip phones that sync to your smartphone, bridging the infinite connectivity of the iPhone and the unrealistic limitations of an early 2000s relic.

Vivo's joint venture could become a template for Chinese smartphone makers in India.

Should Anthropic trust Elon Musk to host its models? With about $40 billion in revenue at stake, Musk insists that the company can.

The company is taking a modular approach to designing these chips, anticipating that their needs will change as AI evolves rapidly by the time the chips are in production.

I built an LED Strip Tetris game — without writing a single line of code. No keyboard mashing. No debugging at 2 AM. No reading 500 pages of datasheets. Just natural language prompts, an AI agent, and a Tuya T5 AI Core board. Here's the full breakdown of how it works 👇 🧩 What Is LED Strip Tetris? LED Strip Tetris is a DIY hardware game built entirely through natural language prompts using TuyaOpen IDE and Claude Code. It runs on a Tuya T5 AI Core development board with a WS2812 LED strip (72 LEDs) and three color-matched buttons — red, green, and blue. Colored LEDs fall from the top of the strip; players press the matching button to shoot a colored LED upward and eliminate the falling one on contact. The entire game — firmware, game logic, hardware wiring, sound effects, compilation, and flashing — was generated by AI. Zero manual coding. 🔌 The Hardware (Ridiculously Simple) Component Role Tuya T5 AI Core Board Main MCU — runs game logic, drives LED strip and buttons WS2812 LED Strip (72 LEDs) Display — colored LEDs fall and get eliminated 3 Push Buttons (Red / Green / Blue) Input — shoot matching color upward to clear falling LEDs Speaker Sound effects on button press That's it. No custom PCB. No complex wiring harness. Just four components plugged into a dev board. 🤔 Why This Is a Big Deal Here's what building a hardware game normally looks like: Step Traditional Approach Vibe Coding with TuyaOpen IDE Dev environment setup Install toolchain, configure SDK, fight dependencies Copy a workflow link, paste into Claude Code, click confirm Game logic Write C code from scratch, design state machines Describe the game in one sentence, AI generates the code Hardware config Read datasheets, look up GPIO mappings, manually configure Tell AI which pins you're using, it handles the rest Sound effects Write audio decoding code, integrate codecs Give AI the file path, it decodes and compiles Debugging Serial logs, oscilloscope, hours of trial and error AI self-diagnoses compile