MakerWire

Electronics, clever builds, and maker projects. Unofficial automated fan feed. Content belongs to its respective owners; not affiliated with source publishers.

Public Key

npub1dmqz603p4dsfpg0txg3v8r6vwf9pkgyz8zm8d7h2eff2gswgr4lqwt7dgd

NIP-05 Address

circuit-raccoon@qwibbit.com

Profile Code

nprofile1qqsxaspd8cs6kcys584nygkr3ax8yjsmyzpr3dnklt4v554yg8yp6lspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dsrsffzu

Publishing to

relay.damus.io

nos.lol

Author Public Key

npub1dmqz603p4dsfpg0txg3v8r6vwf9pkgyz8zm8d7h2eff2gswgr4lqwt7dgd

Show more details

Last Notes

2026-10-29 06:20:43 UTC

From the mail bag…
From the mail bag!
ong time customer here. (maybe a decade? certainly not
as long as some, i’m sure)
i just wanted to send an “we appreciate you!” message (the royal
“you”, obviously. all the named and unnamed folks that make, and have
made, adafruit possible)
i have learned SO VERY much in that time and i cannot thank you enough for
that… im not very bright and have forgotten most of it, but i still did
it!
for example, the wife and i have a small travel trailer that i’m updating
(furniture, plumbing, electrical) and most of the updates that i’m making
are 100% due to confidence inspired from, and some of the knowledge gained
by, the learn guides/docs/forum that adafruit has put out over the years.
don’t worry, it’s only the safe stuff that i’ve applied that
knowledge. all the dangerous stuff was from youtube. promise. it’s very
empowering to encounter a problem and know that i can fix it, work around
it, or improve it using the tools and skills that i’ve gained from this
amazing thing you have built… and home assistant. a LOT of home assistant,
omg. so much HA.
https://blog.adafruit.com/2026/10/29/from-the-mail-bag-811/
https://cdn-blog.adafruit.com/uploads/2025/10/mailbag_animated-2-2.gif
#mailbag #very #lot
#rss #feeds #linksharing #qwibbit

2026-10-28 17:45:02 UTC

3D Print Break-to-Eat Halloween Treats
image via valentinomorandi1 on Instructables
The only way to get the candy hidden inside valentinomorandi1‘s 3D prints is to break them!
Each one cracks open along a single seam that is part of its design:
the ghost opens along the wavy hem of its sheet
the jack-o’-lantern splits right through its zigzag grin
The bottom half survives as a candy bowl. Both have a small peg on top for swappable hats: a pumpkin cap, a witch hat, a top hat, devil horns, a black cat and more.
Read more
HAPPY HALLOWEEN! All month on the Adafruit Blog we’ll be bringing you ideas and projects for an Electronic Halloween
Learn, Shop and get inspired with the Halloween Gift Guide
Working on a project for Halloween this year? Let us know about it or tag us on socials!
https://blog.adafruit.com/2026/10/27/3d-print-break-to-eat-halloween-treats/
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_halloween_sale_2026_1920x1080.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/bte-e1793125677983.gif
https://s.w.org/images/core/emoji/17.0.2/72x72/1f47b.png
#electronichalloween #adafruitblog #giftguide #guideworking #happy #learn
#rss #feeds #linksharing #qwibbit

2026-10-28 16:36:08 UTC

Turning an Old Phone’s Motherboard into an RC Plane Controller
Upcycling smartphones makes a lot of sense, especially since they contain so many components that remain useful long after their desirability as a smartphone has faded. In the case of [Mountain DS Lab], they opted to use an 8-year old Xiaomi Mi 8 phone to add long-range FPV video link and remote control functionality to an RC plane, using the phone’s LTE cellular connectivity.
The smartphone was bought used for $23, with the default Xiaomi ROM overwritten by LineageOS to get a more lightweight and up to date Android installation on it. From the video it’s clear that this phone has seen better days, with the glass back cracked and a few ugly lines running across the display. Fortunately all that is needed is the motherboard itself.
One gotcha here is that the OS checks for the display on boot and will time-out if it’s not present, potentially halting the process entirely. The workaround requires disabling the display in the device tree, which is done by modifying the boot.img file as explained in the video. Next a custom bracket for the motherboard was printed so that it could be fitted inside the target airplane.
To communicate with the avionics, a USB-to-UART adapter PCB was created with a CH340 IC on it. This was then connected together for an initial test, with the extended front camera being used as the FPV camera for the custom Android application. Using the controller via the remote LTE link worked with the flight controller, so next the airplane was assembled for initial testing.
From this point it’s all pretty standard RC airplane assembly and testing, just with the typical RF-based control and FPV link replaced with the LTE link. Unfortunately flying drones isn’t permitted in the immediate area where the creator lives, so only some taxiing was tried prior to its maiden flight at a local airstrip that will be featured in an upcoming video.
Naturally, this isn’t the first time that someone has tried this type of remote control, with the ongoing Russo-Ukraine war being a prime example of LTE-based remote control of drones. Although we do not advocate wiping out a third of a nation’s strategic bomber fleet with upcycled smartphones, ultimately this is the same technology and a good way to create an RC drone that can last more than the few kilometers eked out from a 2.4 GHz link or so. Just be prepared for the LTE link to add a few milliseconds of latency.
https://hackaday.com/2026/10/28/turning-an-old-phones-motherboard-into-an-rc-plane-controller/
https://hackaday.com/wp-content/uploads/2026/10/old_phone_remote_control_mountain_ds_lab_youtube.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/old_phone_remote_control_mountain_testing_ds_lab_youtube.jpg?w=400
https://hackaday.com/wp-content/uploads/2026/10/old_phone_remote_control_mountain_ds_lab_youtube.jpg
#planecontroller #oldphone #lte #fpv #xiaomirom
#rss #feeds #linksharing #qwibbit

2026-10-28 16:03:10 UTC

The past, present, and future share a show floor at Pinball Expo 2026
Nick Indge reported from Pinball Expo 2026 in Schaumburg, Illinois for Ars Technica, after touring Stern Pinball’s factory in Elk Grove. Stern designer George Gomez told the tour group that Stern controls about 90 percent of the pinball market at any given time. The other 10 percent is where much of the new work is happening.
Multimorphic showed its P3 platform, where the lower two-thirds of the machine is a ball-tracking interactive display with floating flippers, slings, and targets, and the upper third is a swappable playfield. Ten playfields exist now, and about 30 games run on the system. Multimorphic offers a free SDK so anyone can write and sell P3 games. Its Dungeon Crawler Carl machine goes into production at the end of the year.
Developer Johnny Zen demonstrated Pocket Pinball, a free Android APK that loads Visual Pinball X tables on a phone or tablet, plus a closed beta of a browser-based Pinball Construction Set with drag-and-drop ramps, targets, and scoops. The homebrew section included Shaolin Flow, which has two fist-shaped sensors above the playfield so players can trigger the flippers by punching.
See more at arstechnica.com.
https://blog.adafruit.com/2026/10/27/the-past-present-and-future-share-a-show-floor-at-pinball-expo-2026/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-112.jpg
#pinballexpo #sternpinball #arstechnica #elkgrove #pinballconstruction #pocketpinball #visualpinball #georgegomez #nickindge #crawlercarl
#rss #feeds #linksharing #qwibbit

2026-10-28 14:53:58 UTC

JPEG-XL Is Back On The Menu
Many of the image formats we’re familiar with have been around for decades. We all know JPEG and PNG like the back of our hands, and GIF even had a bit of a resurgence when tiny annoying looping animations became cool again on social media. There has been a growth in newer formats, though, like WEBP, and AVIF, with various platforms and software companies adopting them for greater efficiency, performance, and image quality.
Amongst the new crop of formats vying for relevance is JPEG XL. It was touted as a format that improved on what JPEG could do in the lossy compression space, while also adding on a lossless mode. There were grand hopes that it would become a universal replacement for all existing raster formats on the Web. A major problem was that Google was seemingly against it, only to backflip—with the format now slated to hit the big time with renewed backing from the search giant. So what’s going on?
Got You JPEG’d
The JPEG XL codec architecture. Credit: Jon Sneyers, CC BY SA 4.0
The JPEG XL standard is modern, but by no means brand new. It was initially released on 13 October 2021, having been developed by a consortium of the Joint Photographic Experts Group, Google, and Cloudinary. It was deveoped from earlier work from Jon Sneyers on the Free Universal Image Format (FUIF), and work from Google on the PIK format.
It was decided the resulting format would use the *.jxl file extension. The spec defined a format with a wide range of features well beyond what classic JPEG ever offered. It has lossless compression, including for the alpha channel, but also lossy compression available in different modes to suit both photographic and synthetic imagery.
It remains fast to decode—almost as fast as JPEG and much quicker than HEIC with x265. A key future proofing feature is that it can also handle 32-bit sample precision, and images with over a billion pixels per side—that’s a terapixel, if you’re playing along at home.
The JPEG XL logo, which pretty much solely exists for people who need an image for their article about JPEG-XL. Credit: Joint Photographic Experts Group
A wide range of major tech companies have backed the standard in the years since it dropped, from Meta, to Adobe, Intel, and Flickr. While it might seem like Google was fully onboard from the get-go, having literally been involved in development of the standard, the history is more complicated, as reported by TT Lab.
Chromium implemented a libjxl-based decoder all the way back in 2021, which seemed to signal JPEG-XL support would soon be a thing in Chrome and other products besides. However, soon enough, there was a change in direction. In late 2022, it was slated for removal, with a notice that ecosystem support wasn’t great enough to justify continued efforts to bring JPEG-XL into the fold.
In Chrome 110, there was no trace left—JPEG-XL was not going to be a part of things. And yet, in the years that followed, debate raged on the Chrome issue tracker as to whether the nascent format would earn its inclusion. Elsewhere, JPEG-XL was struggling to find a footing. Apple rolled it into Safari in 2023, while Mozilla continued to hedge, noting that including another C++ image decoder was undesirable for reasons around memory safety.
A screenshot of an Android media app displaying a *.jxl image. Credit: Syced, CC0
New movement happened in November 2025, when Rick Byers, Area Tech Lead on Google Chrome, noted that the landscape had shifted. He posted that in light of JPEG-XL support being added to things like the PDF format and Safari, amidst other signals of support in the wider ecosystem, that the development team would be open to “integrate a performant and memory-safe JPEG XL decoder in Chromium.”
With Chrome having over 65% of the browser market, this would be a game changer for the format and likely see its adoption skyrocket across the web. It just needed to actually be implemented. However, Byers was careful to note that the inclusion of the new format would be contingent on a commitment to long-term maintenance of the decoder.
Things moved fast, and when Chrome 145 dropped in February this year, JPEG-XL was on the docket. This was thanks to the development of the jxl-rs decoder, which was implemented in Rust. This was an intentional decision for security reasons, with Google relying on the Rule of 2 to keep its browser safe. However, the new decoder was not activated by default. It would take another half a year or so before the new format would become a mainstream part of Chrome, rather than being hidden behind an experimental flag or anything like that. As of Chrome 155, though, JPEG-XL will be fully supported in the browser.
Don’t expect to see a ton of *.jxl files out on the wider web immediately. However, with the new format offering 30-50% better compression than JPEG, it will be appealing to just about any content provider looking to slimline data budgets and improve page loading times. When the performance gains start boosting traffic to a degree that makes up for the loss of users from older non-compliant browsers, expect to see things changing more quickly.
What does it mean for you, the end user? Probably little more than some minor headaches. You’ll struggle here and there when you download a *.jxl and try and load it into older software that doesn’t support it. You might get a device that shoots pictures in JPEG-XL and then find you can’t upload them to an older website with an out-of-date image submission form.
It’s the same problem we’ve all dealt with as HEIC, AVIF, and WEBP have started bouncing around the web, and we’ll have to weather it again. At least, at the end of the day, we’ll have slightly prettier images that take up a little less space. It’ll all be worth it, to be sure.
https://hackaday.com/2026/10/28/jpeg-xl-is-back-on-the-menu/
https://hackaday.com/wp-content/uploads/2026/10/jxl_logo.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/JPEG_XL_codec_architecture.svg_.webp?w=372
https://hackaday.com/wp-content/uploads/2026/10/Screenshot-2026-10-28-155224.png?w=318
#jpeg #back #google #jonsneyers #expertsgroup #photographicexperts #jointphotographic
#rss #feeds #linksharing #qwibbit

2026-10-28 14:20:50 UTC

Amico8 – PICO-8 fantasy console emulator for Amiga
Juen^Appendix+Nah-Kolor posted a demonstration on YouTube of Amico8, a PICO-8 fantasy console emulator that runs on the Amiga. PICO-8 games are small cartridges built around a 128×128 display and a fixed 16 color palette, and Amico8 plays them on Amiga hardware.
The four minute video shows the emulator pulling games at random with an F5 shortcut, drawing from a library of over a thousand titles. The emulator is available for download from juen.in.
See the video below.
https://blog.adafruit.com/2026/10/27/amico8-pico-8-fantasy-console-emulator-for-amiga-youtube-com/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-113.jpg
#fantasyconsole #consoleemulator #amiga #appendix #youtube
#rss #feeds #linksharing #qwibbit

2026-10-28 13:10:54 UTC

Emulate the 486 in Your Browser
You might fondly remember the days of the Intel 486, but you probably don’t have one on your desk anymore. If you’d like to emulate that classic hardware, you can now do it in your browser, thanks to [Jan de Jager].
What [Jan] has built is a 100% browser-based emulator for an Intel 80486DX2-66 PC. Obviously, it’s not just a CPU that’s being emulated here—[Jan] has gone so far as to throw in the motherboard and ISA/VLB adapter card emulation necessary to make this a real and functioning computer that runs inside a solitary browser tab.
It’s all written in ES6 JavaScript. It will happily run SeaBIOS, VGA BIOS, FreeDOS 1.3, and a whole bunch of classic games, like Wolfenstein 3D, Duke Nukem, and DOOM. There’s even a control panel where you can configure the PC how you like, from storage to expansion cards and all the rest.
Once upon a time an emulator was an application you had to download and run, hoping all the while that your new machine had enough grunt to emulate the classic hardware of your desires. These days, we have endless piles of CPU cycles to throw at everything and you can do it all within a browser. Or even on a tiny microcontroller, if you feel like it!
https://hackaday.com/2026/10/28/emulate-the-486-in-your-browser/
https://hackaday.com/wp-content/uploads/2026/10/crt-monitor-e1793155369528.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/crt-monitor-e1793155369528.png
#browser #jan #intel #dukenukem #cpu #jager #isa #vlb #bios #vga
#rss #feeds #linksharing #qwibbit

2026-10-28 12:37:17 UTC

Raspberry Pi 5 on Fedora
nullr0ute writes on nullr0ute.com that the Raspberry Pi 5 has worked out of the box on Fedora since the Fedora 44 release. It is described as a Minimum Viable Product: the key pieces work, with caveats. It provides an accelerated desktop along with storage, network and USB. Sound is not supported yet, along with a number of other things.
Fedora 44 needs a temporary workaround at boot, passed as a kernel argument through arm-image-installer. That goes away once you update to the latest kernel and firmware. Fedora 45 does not need it at all, so the suggestion is to grab a Fedora 45 release candidate and flash it the same way you would for any other Raspberry Pi, including to NVMe.
Since the Fedora 44 release in May, more features have gone upstream from several contributors, and those changes are making their way back into Fedora. Support for the Raspberry Pi 500 and CM5 is planned.
See more at nullr0ute.com.
https://blog.adafruit.com/2026/10/27/raspberry-pi-5-on-fedora/
https://cdn-blog.adafruit.com/uploads/2026/10/aa-19.png
#fedora #raspberry #viableproduct #minimumviable #usb #may #sound
#rss #feeds #linksharing #qwibbit

2026-10-28 10:56:13 UTC

6 stellar images of the early universe
The Popular Science Team has posted a gallery from Lumina, a new simulation of the early universe built by a team at the Center for Astrophysics | Harvard & Smithsonian. The work is described in a study published in Monthly Notices of the Royal Astronomical Society.
Lumina models how ordinary matter, dark matter, and radiation interacted during the universe’s first 2 billion years. It is the largest cosmological radiation-hydrodynamics simulation made so far, and running it took more than 15,000 graphics processing units. The renderings cover a stretch of the cosmic web about 650 million light-years across, with filaments marking dark matter and color marking where hydrogen and helium shifted into their modern ionized forms.
The point of all that compute is comparison. Astronomers can hold observations from the James Webb Space Telescope and the Nancy Roman Space Telescope up against Lumina’s predictions and see whether current theory still holds. Lead author Oliver Zier, an ITC Fellow at the Center for Astrophysics, said the team needed to translate theory into detailed predictions to understand what JWST is showing.
See the video below and more at popsci.com.
https://blog.adafruit.com/2026/10/27/6-stellar-images-of-the-early-universe/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-114.jpg
#earlyuniverse #spacetelescope #popularscience #lumina #astronomicalsociety #monthlynotices #royalastronomical #scienceteam #romanspace #webbspace
#rss #feeds #linksharing #qwibbit

2026-10-28 09:48:31 UTC

SLAM Navigation For an Arduino Powered Car
There are plenty of “robot” projects out there that are really just a small remote control platform of some sort. We often like to think of robots of having some sort of autonomy though. [Luca Fagioli] demonstrates a great example of this with his explorer robot that uses Simultaneous Localization and Mapping (SLAM) to navigate its environment.
The robot is a built on a small plastic chassis, with one gear motor per drive wheel. Running the show is an Arduino Uno R4 Wi-Fi, paired with the Sensor Shield 5.0 and an L298N motor driver board. There’s also an HC-SR04 ultrasonic sensor module onboard, mounted atop an SG-90 servo motor so it can be panned around. The ultrasonic sensor determines the range between the robot and surrounding walls, and a map is constructed at the same time as the robot is localizing itself within it. There are also infrared sensors on the bottom of the robot for detecting tape marks on the floor for checkpointing purposes.
Often, SLAM mapping is done with advanced laser rangefinders or time of flight sensors, but there are many ways to go about it as this project demonstrates. We’ve even seen it done in a distributed manner with coordinated drones combining their efforts. Overall, it’s a highly useful technique for robot navigation and wayfinding.
https://hackaday.com/2026/10/28/slam-navigation-for-an-arduino-powered-car/
https://hackaday.com/wp-content/uploads/2026/10/4WD-SLAM-RADAR-2D-ROBOT-CAR-0-25-screenshot.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/4WD-SLAM-RADAR-2D-ROBOT-CAR-0-25-screenshot.png
#slam #lucafagioli #simultaneouslocalization #sensor #often #shield #uno
#rss #feeds #linksharing #qwibbit

2026-10-28 09:15:48 UTC

A quick history of porcelain
Jason Kottke, writing at kottke.org, points to a short history of porcelain from Charles Mann. The subject came up because the glass-ceramic surface of Mann’s expensive induction stovetop is essentially the same material.
Kottke adds a note of his own: he studied ceramic engineering in grad school before leaving after one semester to teach himself web design.
See more at kottke.org.
https://blog.adafruit.com/2026/10/27/a-quick-history-of-porcelain/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-115.jpg
#history #porcelain #charlesmann #kottke #jasonkottke #see
#rss #feeds #linksharing #qwibbit

2026-10-28 08:06:12 UTC

RAM: the forgotten history
lcamtuf has posted a history of working memory on blog.coredump.cx, arguing that RAM gets far less attention than Babbage and that memory constraints held back personal computing until the end of the 20th century.
The post starts with relay latches, including the roughly 2,000 relays in the memory unit of Konrad Zuse’s Z3, against about 600 for the rest of the machine. It moves to the 1918 Eccles-Jordan bistable tube circuit, the ancestor of the SR latch cells in SRAM today.
Tubes and relays were too expensive for bulk memory, so machines used dynamic schemes instead: the spinning capacitor drum of the Atanasoff-Berry computer, mercury delay lines like the one in UNIVAC I, torsion wire memory in the Monroe 925 calculator, and the Williams and RCA Selectron tubes that stored bits as visible dots on phosphor. Magnetic drums and then woven ferrite core memory followed, with one 8×8 inch module holding 32 kB.
lcamtuf notes that magnetic RAM survives: Everspin sells MRAM up to 16 MB that acts like SRAM but keeps data without power.
See more at blog.coredump.cx.
https://blog.adafruit.com/2026/10/27/ram-the-forgotten-history/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-116.jpg
#ram #history #konradzuse #rcaselectron #tubes
#rss #feeds #linksharing #qwibbit

2026-10-28 06:54:03 UTC

pico_hdmi: HSTX-native HDMI output library for RP2350 with hardware TMDS encoding and audio support
Weeb Labs has published pico_hdmi on GitHub, a video and audio output library for the RP2350 and Raspberry Pi Pico 2. It uses the chip’s HSTX peripheral and its hardware TMDS encoding, so there is no bit-banging and no overclock needed for 480p output. The library handles sync polarity and HDMI Data Island placement for each mode on its own.
Audio runs at 48kHz by default, with 32000, 44100, 88200, 96000, 176400 and 192000 Hz also supported. Output pins default to CLK on GPIO12/13 and the three data pairs on GPIO14 through GPIO19, and boards that swap lanes or polarity can pass in their own pinout. The pads are set to fast slew and 12mA drive for edge margin at 720p60.
A 2.0 beta branch adds an opt-in scanout path for applications doing heavy per-line work, overlays, 320 to 640 scaling, or live capture. One mode lets the callback return a 320-pixel RGB565 line that DMA doubles to 640 output pixels. The 720p builds need the RP2350 at 372 MHz with 1.3V core voltage. Released under the Unlicense.
See more on GitHub.
https://blog.adafruit.com/2026/10/27/pico_hdmi-hstx-native-hdmi-output-library-for-rp2350-with-hardware-tmds-encoding-and-audio-support/
https://cdn-blog.adafruit.com/uploads/2026/10/pico-2w.png
#tmdsencoding #hardwaretmds #hdmi #outputlibrary #pico #audio #dataisland #weeblabs #github #hstx
#rss #feeds #linksharing #qwibbit

2026-10-28 05:47:58 UTC

Hacking a Marine Radio Dish
Having watched some fun videos on repurposed satellite dishes on YouTube, [Melan] wanted to get in on the action. She managed to source herself an Intellian i4, a dish built for marine use, and set about hacking it to do her bidding.
[Melan] first set about convincing the antenna that it was still on a boat by using an RP2040 microcontroller and an RS-422 module to send NMEA sentences. This was necessary to tell the i4 the “heading” of the “boat”, even though [Melan] was really using the rig on land. From there, she was able to get the Intellian software to run the antenna just by emailing the company.
However, she wanted to see if it could be controlled without it. She began by sniffing communications between the software and the Antenna Control Unit, and decompiling the code. It was relatively straightforward to put together a protocol description and figure out how to command the antenna where to point simply by issuing commands for azimuth and elevation.
We’ve featured other great bits of satellite equipment before, like this truck tracker teardown from a few years ago. If you’ve got some nice equipment on the bench that listens in on (or transmits out to) birds in space, don’t hesitate to let us know on the tipsline.
https://hackaday.com/2026/10/27/hacking-a-marine-radio-dish/
https://hackaday.com/wp-content/uploads/2026/10/intellian_i4_roof-e1793151930376.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/intellian_i4_roof-e1793151930376.png
#dish #melan #antenna #hacking #intellian #controlunit #nmea
#rss #feeds #linksharing #qwibbit

2026-10-28 05:14:24 UTC

An exhibition of ukiyo-e (woodblock prints) by Utagawa #ArtTuesday
Jason Kottke wrote on kottke.org about visiting an exhibition of ukiyo-e woodblock prints by Utagawa Hiroshige at the Tokyo National Museum.
Ukiyo-e prints were made by carving a design into blocks of wood, inking them, and pressing them onto paper, with a separate block for each color. Hiroshige worked in the 1800s and is known for landscape series. Kottke’s take was that seeing the prints in person was the best part.
See more at kottke.org.
https://blog.adafruit.com/2026/10/27/an-exhibition-of-ukiyo-e-woodblock-prints-by-utagawa-arttuesday/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-117.jpg
#rss #feeds #linksharing #qwibbit

2026-10-28 04:08:17 UTC

Airborne Particle Monitoring, the BIG way
Airborne micro particles can be a significant health hazard in a workshop, and thus it’s important to maintain a high standard of ventilation. But monitoring their concentration is also important, and thus there exists a range of sensors to help keep you safe. [WeSpeakEnglish] has taken this idea to the MAX, with a PM2.5 sensor that drives a very large wall mounted display. You’ll never be uncertain what the level is now!
The standout feature of this thing is a huge addressable LED seven segment display PCB, upon the back of which sits a tiny Seeed Studio Xiao board to which the particle sensor is hooked up. The software displays the particle count, and handily changes the colour as the number creeps upwards. Meanwhile should you wish to log the readings, the USB exposes a serial port upon which they are placed.
We can see this is a useful project for anywhere that is likely to have a high particle count, but it’s worth noting also that a large 7-segment display with an ESP32 board attached could have plenty of other uses. Meanwhile this is a nicely finished air quality monitor, but it’s certainly not the first we’ve seen.
https://hackaday.com/2026/10/27/airborne-particle-monitoring-the-big-way/
https://hackaday.com/wp-content/uploads/2026/10/pm2.5-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/pm2.5-featured.jpg
#particlemonitoring #airborneparticle #seeedstudio #studioxiao #meanwhile #max #pcb #led
#rss #feeds #linksharing #qwibbit

2026-10-28 03:55:24 UTC

JP’s Product Pick of the Week — 3pm Eastern TODAY 10/27/26 @adafruit #adafruit #newproductpick
Come on by for JP’s Product Pick of The Week ! A new product pick will be revealed. The show airs at 3pm ET / 12pm PT
Check out the livestream right here inside this product page you won’t want to miss it because there will be a LARGE DISCOUNT during the show!
Tune in for:
John Park’s newest product pick
Learn how to use it
Live Demo
The live video will also be on YouTube LIVE, Twitch, Periscope (Twitter) and Facebook. LIVE TEXT CHAT IS HERE in the Adafruit Discord chat! Come on into the chat to participate!!
Every Tuesday @ 3pm ET/12pm PT!
https://blog.adafruit.com/2026/10/27/jps-product-pick-of-the-week-3pm-eastern-today-10-27-26-adafruit-adafruit-newproductpick/
https://cdn-blog.adafruit.com/uploads/2026/10/jpppw_thumb_episode299_BLUR.jpg
#rss #feeds #linksharing #qwibbit

2026-10-28 03:01:51 UTC

A Shapeshifting LED Mask for Halloween
Sebastian Staacks from There Oughta Be built an LED mask that can change into any face using matrix panels, a Raspberry Pi Pico, and zip ties.
The post A Shapeshifting LED Mask for Halloween appeared first on Make: DIY Projects and Ideas for Makers.
https://makezine.com/article/craft/a-shapeshifting-led-mask-for-halloween/
https://i0.wp.com/makezine.com/wp-content/uploads/2026/10/Staaks-Halloween-LED-Mask-scaled.png?fit=750%2C389&ssl=1
#rss #feeds #linksharing #qwibbit

2026-10-28 01:39:35 UTC

nrf54-arduino-core: nRF54 Arduino core for XIAO nRF54L15 and other nRF54 boards
Lolren has published nrf54-arduino-core on GitHub, an Arduino core for Nordic’s nRF54L family that talks to the hardware at the register level. There is no Zephyr runtime underneath and no separate nRF Connect SDK install. Targets include the Seeed XIAO nRF54L15 and XIAO nRF54LM20A, HOLYIOT modules, generic modules and the Nordic nRF54L15 DK.
The usual Arduino calls work: pinMode, digitalWrite, analogRead, Wire, SPI and Serial.
Bluetooth LE is the main wireless surface, with a bundled Bluefruit52Lib compatibility layer so Adafruit-style sketches port over with small changes. ArduinoBLE is not the native BLE library here.
The core also exposes the VPR RISC-V coprocessor and handles board-specific sleep, including the nPM1300 PMIC and QSPI flash deep power-down on the LM20A.
It is installed through the Arduino IDE Boards Manager, or use PlatformIO, which has been supported since release 1.0.21 with GDB debugging and Unity tests. Thread, Matter, Zigbee and Channel Sounding are included for evaluation and are marked experimental, outside the stable feature claim.
See more on GitHub.
https://blog.adafruit.com/2026/10/27/nrf54-arduino-core-nrf54-arduino-core-for-xiao-nrf54l15-and-other-nrf54-boards/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-119.jpg
#arduinocore #xiao #seeedxiao #boards #connectsdk #ideboards #channelsounding #github #wire
#rss #feeds #linksharing #qwibbit

2026-10-28 00:32:09 UTC

How a Single University Project Started Everything
If we care to cast an eye over the history of ubiquitous personal computing as we know it today, we might immediately point at the original IBM PC. After all, for most of us our machines share backward compatibility in some form through multiple generations back to that original box from 1981.
But if we look at the things we use today and take for granted, from laser printers to graphics cards to the routers which power most of the Internet, they’re not from IBM at all. At the recent Vintage Computing Festival Berlin, [Michael Engel] delivered a talk naming a surprising progenitor for much of that technology, none other than Sun Microsystems.
It all starts with [Andy Bechtolsheim], famously Sun’s co-founder, when at the end of the 1970s he was a postgraduate at Stanford University. Working on the Stanford University Network — SUN — project he designed a computer to be used as a workstation on the network. The processor of choice then was Motorola’s 68000, but it lacked the MMU that would be required to run UNIX. His design had an MMU implemented externally to the 68000, with a bank of SRAM serving as the page table. This design would form the CPU board of the first Sun workstation.
The story might end there, were it not that many other companies had the same requirement, and Sun could supply them a CPU board. Silicon Graphics, the distant ancestral progenitor of your GPU, was one of them, so the first SGI workstation also had the same CPU as the first Sun. It appeared in the early Imagen laser printers too, as well as commercial AppleTalk to Ethernet bridges. Perhaps the biggest surprise is that because the original Stanford board had also been used as a router, the software for that became part of Cisco’s first product.
The video is below the break, and it’s a fascinating watch.
https://hackaday.com/2026/10/27/how-a-single-university-project-started-everything/
https://hackaday.com/wp-content/uploads/2026/10/sun1-cpu-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/sun1-cpu-featured.jpg
#stanforduniversity #sun #cpu #sunmicrosystems #ibm #michaelengel #festivalberlin #computingfestival #vintagecomputing #andybechtolsheim
#rss #feeds #linksharing #qwibbit

2026-10-27 23:59:23 UTC

You can now run Nintendo Switch games natively on iPhones and Macs
Zo Ahmed, writing for TechSpot, covered nxnative, an open-source project that converts Switch games a user already owns into native iPhone, iPad, and Mac apps. There is no emulator. The game’s original Arm code runs directly on Apple silicon. Only the Nintendo-specific parts get replaced: a small host program stands in for the Switch operating system, and graphics calls are translated to Apple’s Metal API.
The GitHub page lists more than 60 tested games, including Mario Kart 8 Deluxe, Metroid Dread, and Super Mario Odyssey. With a particular game update, Breath of the Wild and Tears of the Kingdom can run at 60 fps instead of the Switch’s 30.
Setup is not quick, though. It needs your own game files and decryption keys pulled from your own console, plus a Mac running Xcode. The first build can take an hour. The finished app is sideloaded with AltStore or Sideloadly, and runs only on an iPhone 15 Pro or newer, or an M1 iPad or newer, on iOS 26 or iPadOS 26. amiibo support and online play do not work.
See more at techspot.com and content on GitHub.
https://blog.adafruit.com/2026/10/27/you-can-now-run-nintendo-switch-games-natively-on-iphones-and-macs/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-121.jpg
#nintendoswitch #switchgames #macs #run #metalapi #metroiddread #mariokart #marioodyssey #apple #supermario
#rss #feeds #linksharing #qwibbit

2026-10-27 22:19:45 UTC

Python’s experimental just-in-time (JIT) compiler to be removed
Writing at LWN.net, jzb reports that CPython’s experimental just-in-time compiler is being removed. The JIT landed in CPython in 2024 for the 3.13 release.
In June, the Python steering council paused work on the JIT in CPython’s main branch. The council wanted an accepted Python Enhancement Proposal first, one that addressed maintenance and compatibility concerns and set success metrics and a timeline for completion.
The JIT maintainers wrote PEP 836, “JIT Go Brrr: The Path to a Supported JIT Compiler for CPython,” to answer that request. After months of discussion, they withdrew it. Development on the project appears to have ended.
See more at lwn.net.
https://blog.adafruit.com/2026/10/27/pythons-experimental-just-in-time-jit-compiler-to-be-removed/
https://cdn-blog.adafruit.com/uploads/2026/10/python.png
#jit #experimental #python #compiler #removed #supportedjit #pythonenhancement #enhancementproposal #june #brrr
#rss #feeds #linksharing #qwibbit

2026-10-27 21:41:44 UTC

2026 Retrocomputing Challenge: Explore Space with a Credit Card Reader
The humble credit card reader — most of us have used hundreds, perhaps even thousands of them over the years. But even for folks like us, it’s not the sort of device we give a lot of thought to. It’s just a keypad, a display, and a magnetic stripe reader. How interesting could it possibly be?
That may be true in some cases, but at least for the 1990s-era TRANZ 330, there’s a bit more to the story than that. As [CharlesD] explains, these particular readers are essentially complete Z80 computers just waiting to do something more exciting than processing PINs. In the case of this particular unit, the addition of a GPS module and some new code has turned it into an interactive guide to the solar system.
Thanks to the UV erasable ROMs used in the TRANZ 330, loading new code on the device is easy enough. With a bit of educated poking around, [CharlesD] was able to map out what did what. Working from the basics of getting the display and keypad working, he moved onto the serial interface, which in turn let him communicate with a modern GPS module and era-appropriate thermal printer. From there it was just a matter of getting the math implemented to compute the azimuth and elevation of a given planet, and he had an offline map of the solar system for use with his telescope.
This is one of those projects which is awesome enough on its own merits, but it’s particularly exciting to see just how easy it is to repurpose one of these card readers, especially since [CharlesD] was kind enough to share his source code. If you end up picking one of these up and getting something running on it, be sure to let us know.
https://hackaday.com/2026/10/27/2026-retrocomputing-challenge-explore-space-with-a-credit-card-reader/
https://hackaday.com/wp-content/uploads/2026/10/z80planets_feat.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/z80planets_detail.jpg?w=400
https://hackaday.com/wp-content/uploads/2026/08/RetroComputing_728x90.jpg
#creditcard #cardreader #charlesd #tranz #gps
#rss #feeds #linksharing #qwibbit

2026-10-27 21:07:47 UTC

An illustrated online book on Hewlett-Packard equipment
A free 550 page e-book collects classic Hewlett-Packard test gear from the 1950s to the 1990s, with photos, schematics notes and restoration tips. Most of the instruments covered are ones the writer owns and tested.
Sections cover voltmeters, including the 400H vacuum tube voltmeter and the 410C with its photoconductive chopper amplifier, the 8640B signal generator, the 8015A pulse generator, the 54502A and 54540A oscilloscopes, the 5316B counter, the 141T spectrum analyzer with the 8553B and 8552B plug-ins, and the 8443A tracking generator.
Calculators get their own section: the HP-35, 45, 67 and 41C, plus the HP-85 computer. There is also a chapter on HP-IB, the interface bus better known as IEEE-488.
See more at k100.biz. (a large PDF)
Via Dave Jones on X.
https://blog.adafruit.com/2026/10/27/an-illustrated-online-book-on-hewlett-packard-equipment/
https://cdn-blog.adafruit.com/uploads/2026/10/aaa-23.png
#book #viadave #davejones #pdf
#rss #feeds #linksharing #qwibbit

2026-10-27 19:52:27 UTC

The roadmap to becoming a computer vision engineer in 2026
Vinod Chugani has published a four-stage study plan for computer vision engineers at KDnuggets. Each stage builds on the one before it, and each ends with a portfolio exercise.
Stage one is the math: matrix transformations, coordinate frames, projective geometry, and multi-view geometry, plus PyTorch tensor work and augmentation with Albumentations. Stage two covers Vision Transformers and Swin Transformers, then vision-language models like CLIP and SigLIP, open-vocabulary detection with OWL-ViT and Grounding DINO, and promptable segmentation with Meta’s SAM 2.
Stage three moves to 3D: point clouds, voxel grids, signed distance fields, monocular depth with Depth Anything v2, NeRFs and 3D Gaussian Splatting, and visual odometry and SLAM. Stage four is deployment, covering model compression and runtimes including TensorRT, ONNX Runtime, and OpenVINO, with hardware targets such as NVIDIA Jetson, Apple Silicon’s Neural Engine, and the Raspberry Pi AI Kit. Multi-camera streaming at 30+ FPS gets its own treatment through NVIDIA DeepStream. One suggested exercise: export YOLOv8 or RT-DETR to ONNX, quantize with TensorRT, and benchmark FP32 against INT8.
See more at kdnuggets.com and content on GitHub.
https://blog.adafruit.com/2026/10/27/the-roadmap-to-becoming-a-computer-vision-engineer-in-2026/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-122.jpg
#computervision #visiontransformers #stage #groundingdino #gaussiansplatting #nvidiajetson #vinodchugani #onnx #applesilicon #neuralengine
#rss #feeds #linksharing #qwibbit

2026-10-27 18:45:39 UTC

Where Did Your Mouse Come From?
Many readers will be familiar with Douglas Englebart’s 1968 so-called “Mother of All Demos”, in which he described many of the devices and technologies we would be using two or three decades later. Among these was a primitive computer mouse, but while famous it was by no means the earliest pointing device. At the recent Vintage Computer Festival Berlin, [Dmitriy Kostiuk] delivered a fascinating lecture of the history of the pointing device.
It’s a long video that we’ve placed below, and it’s an exhaustive examination of the topic from the earliest examples to the 1990s when mice became commoditized. It’s a surprise to find that the first pointing device was a trackball built for a 1950s Canadian warship, with a surprisingly modern-looking optical encoder. Englebart’s 1966 wooden block with its pair of wheels and potentiometers had a less-well-known and much more stylish competitor in the same year from Telefunken.
We visit the various design iterations as the form of what we’d call a mouse today took shape. It’s unexpected to find that those Sun mice with the spotty mouse pad weren’t from Sun at all, they were from Mouse Systems. The first mice from Microsoft and Apple make an appearance, as do some awful designs for 8-bit computrs. Remembering those in particular perhaps it’s as well we didn’t have the cash to buy such a disappointing product for ourselves.
The video is long, but interesting. Give it a watch.
Header image, Douglas Englebart’s prototype, Michael Hicks, CC BY 2.0.
https://hackaday.com/2026/10/27/where-did-your-mouse-come-from/
https://hackaday.com/wp-content/uploads/2026/10/mouse-history-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/mouse-history-featured.jpg
#douglasenglebart #mousesystems #dmitriykostiuk #festivalberlin #computerfestival #vintagecomputer #sun #michaelhicks #demos
#rss #feeds #linksharing #qwibbit

2026-10-27 18:11:21 UTC

BirriaSDR turns a USB WiFi dongle into an experimental SDR receiver
Luigi Cruz has published BirriaSDR on GitHub, a project that turns a USB WiFi dongle into an experimental SDR receiver with 14-bit I/Q at 40 million complex samples per second. The tested hardware is a COMFAST MT7961/MT7921AU dongle, pairing an MT7961 digital die with an MT7972 analog die.
WiFi chips already contain a wideband receiver, and some include an internal I/Q capture engine meant for calibration and debugging. BirriaSDR repurposes that path. The host programs the front end and capture engine through their registers, and a 1,632 byte device program, loaded through the chip’s boot ROM, ships the samples to the host over USB. No vendor firmware is downloaded, and nothing is written to flash or eFuse, so all configuration disappears at power off.
The code ships as libbirriasdr, a C11 library with an API modeled on librtlsdr, plus a command-line recorder. It tunes 2156 to 2610 MHz and 4500 to 6200 MHz, including while streaming. A CyberEther flowgraph is included as a rough proof of concept for watching a live spectrum without building a thing. Sensitivity, frequency accuracy and gain are not calibrated.
See more on GitHub.
https://blog.adafruit.com/2026/10/27/birriasdr-turns-a-usb-wifi-dongle-into-an-experimental-sdr-receiver/
https://cdn-blog.adafruit.com/uploads/2026/10/a.png
#experimentalsdr #usbwifi #sdrreceiver #wifidongle #turns #luigicruz #github #mhz #comfast #rom
#rss #feeds #linksharing #qwibbit

2026-10-27 16:52:23 UTC

The Tiny Computers app lets you play with old computers
Jason Kottke, writing on kottke.org, points to Tiny Computers, an iPhone app that puts working miniature versions of vintage machines on your screen.
Ten machines are included: Macintosh, Commodore 64, IBM PC, Amiga 500, Windows 95, ThinkPad, iMac G3, iBook G3, PowerBook G4 and Windows XP. The Windows XP model even crashes from time to time.
See the video below and more on kottke.org.
https://blog.adafruit.com/2026/10/27/the-tiny-computers-app-lets-you-play-with-old-computers/
https://cdn-blog.adafruit.com/uploads/2026/10/aaa-22.png
#tinycomputers #windows #app #jasonkottke #amiga #commodore #macintosh #ibm #ibook #imac
#rss #feeds #linksharing #qwibbit

2026-10-27 15:29:16 UTC

How Bad Is That Bridge: A Government Database
Bridges! We kind of expect them to just be there and do their job, ad infinitum. They are built into the landscape, and we often take them and the routes they open up for granted.
The reality, as any civil engineer will tell you, is that bridges are living, breathing things that require endless maintenance and monitoring to keep them safe, standing, and functional. A great example of this is found in the US Department of Transportation, and its publicly accessible register of bridge health reports.
Stay Standing
The thing about bridges is that we rely on them. They serve as vital transport links in our communities, ferrying people to and from work and school, and acting as the very arteries of commerce as trucks and trains haul goods to and fro. When a bridge crossing has to close, either for maintenance or at end of life, this link is severed, often with serious economic and logistical impacts. For that reason, we tend to like to keep our bridges in service as long as possible. The result, of course, is that if pursuing this goal means that proper maintenance and repairs aren’t seen to, there is a risk of collapse—which often comes with worse consequences. Loss of life is common when bridges fail, and replacing a collapsed bridge is often much harder and more time consuming than handling things properly ahead of time.
In the United States, it’s a well known fact that the bridges are getting old. The average bridge is 44 years old, which is bumping up against the 50-year service limit many were originally built for. Being an average number, it’s indicative that many bridges are exceeding that figure significantly. Obviously, a bridge’s age isn’t a perfect proxy for its condition, but closer examinations indicate there’s definitely a problem. A 2024 report from the American Road & Transportation Builders Association noted that 36 percent of US bridges are in need of repair or replacement, a total of 221,800 spans. 42,067 spans were considered to be in “poor” condition, which in their total see 168.5 million motorists crossing them every day. It’s a particularly sobering figure as it highlights the size of the disaster possible if these structures are to fail.
InfoBridge quickly lets you sort through data by all kinds of different factors. If you’re looking for the worst bridges in town, it’s easy to flick through CAT10 – BRIDGE CONDITION to see which bridges as listed as Good, Fair, or Poor. Bridges are rated on the condition of their deck, superstructure, and substructure, and the lowest scoring section influences which bin the bridge lands in, as per federal code—specifically, 23 CFR 490 Subpart D. Credit: InfoBridge screenshot
You can drill down into the data yourself if you desire. Within the Department of Transport, the Federal Highway Administration maintains LTBP InfoBridge, a database of information on bridges all across the country. It was developed by the Long Term Bridge Performance program, because the goal of the project is to understand how these structures hold up and perform over the decades. The database is publicly accessible, and serves as a portal for all the available data and statistics on how US bridges are doing. It hopes to enable everyone from state and federal authorities, to university students, faculty, and other researchers, to dive into bridge data and visualize and understand it better.
Data available is from a wide number of sources, including the National Bridge Inventory and National Bridge Element datasets, as well as climatic data collected from NASA’s MERRA-2 database. There’s also construction and design data sourced by the LTBP program, along with non-destructive evaluations that have been carried out. Data from various other special projects is available too, such as from Federal Highway Administration projects investigating timber bridges, steel weathering, and the use of ultra-high performance concrete structures.
Just glancing at the Vincent Thomas bridge won’t tell you how the structure is doing. Credit: The Port of Authority, CC BY-SA 3.0
If you have a particular bridge of interest, it’s easy to get a quick break down of how it’s doing. For example, you might like to know about the Vincent Thomas Bridge, in Los Angeles, California: National Bridge Inventory number 53 1471. It links San Pedro with Terminal Island, and is a suspension bridge with a total length of 6,060 feet and a longest span of 1,500 feet. Built in 1963, we can see from the data alone that it’s now showing its age.
The bridge condition is listed as “Poor,” and if we dive deeper into the National Bridge Elements data, we can see why. The health indexes of the deck, substructure, and superstructure have all been trending down in recent years as the bridge’s age has increased, with a particular drop off from 2019 or so. In particular, the steel cables and girders on the bridge have been showing their age, and the concrete columns supporting the bridge have been similarly degrading. The deck, too, is in need of repair, with the California Department of Transport recently dedicating some $706 million to replace it ahead of the 2028 Olympic Games.
However, InfoBridge will let you drill down into detailed reports on the bridge conditions, down to a level which indicates which parts of the bridge are most in need of maintenance, repair, or replacement. Credit: Screenshot, InfoBridge
InfoBridge also offers condition forecasts for many bridges across the country. For example, the 24th Street Bridge over Rio Linda Creek is currently listed as being in “Good” condition. Current forecasts show that the deck and superstructure is expected to be in much poorer shape somewhere between 2035 and 2055, while the substructure is expected to hang on in good shape for a bit longer.
The Long Term Bridge Performance Program has developed a variety of models—base, survival, and machine-learning—to predict bridge condition over time. The aim is to guide maintenance efforts over time and allow for better planning. Credit: InfoBridge, screenshot
You might think that you’d have to query a government department and delve deep into some dusty records room to learn about the condition of your local bridges. Instead, thanks to the efforts of diligent civil servants, you can instead access all the rich inspection data you like from the comfort of your own web browser. It’s not just good for citizen oversight, either. It aids local authorities and bridge owners in making the right decisions, by putting the necessary data right at their fingertips.
It also creates a certain level of accountability—having the data available means there’s little room for anyone to make excuses that they were unaware of a bridge’s condition prior to something going wrong. Ultimately, it’s just one arm of a project that hopes to take US bridges safely long into the future.
Featured image: “Brooklyn Bridge – New York City” by [Simone Roda]
https://hackaday.com/2026/10/27/how-bad-is-that-bridge-a-government-database/
https://hackaday.com/wp-content/uploads/2026/10/Brooklyn_Bridge_-_New_York_City_featured.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/Screenshot-2026-10-23-132108.png?w=400
https://hackaday.com/wp-content/uploads/2026/10/Vincent_Thomas_Bridge_2.jpg?w=400
#bridges #database #condition #transportation #department #infobridge #standing #poor #unitedstates #federal
#rss #feeds #linksharing #qwibbit

2026-10-27 14:56:39 UTC

ICYMI Python on Microcontrollers Newsletter: CircuitPython 11.0.0-alpha.2 Is a Huge Update, Internet Security Issues Abound and More!
If you missed this week’s Python on Microcontrollers Newsletter, here is the ICYMI (in case you missed it) version.
To never miss another issue, subscribe now! – You’ll get a terrific newsletter each Monday (which is out before this post). 12,328 subscribers worldwide!
The next newsletter goes out Monday morning and subscribing is the best way to keep up with all things Python for hardware. No ads or spam, no selling lists, leave any time.
From the Editor:
Welcome to the latest Python on Microcontrollers newsletter! It’s been a tough week for many folks, with security issues found in PHP, security certificates and more. The sysadmins have had a rough time. In looking for news, I report the issues most affecting the Python on hardware world.
The biggest news is the scope of the updates to CircuitPython. 11.0.0-alpha.2. This release contains a large number of changes, likely the most for a “minor” release. The capabilities are growing at a healthy rate and worth looking at if you would like some speed improvements or fancy new features. Of course, there is the cornucopia of other items in this issue worth looking at, too. I wish all who celebrate a happy Halloween. – Anne Barela, Editor
We’re on Discord, Twitter/X, BlueSky and for past newsletters – view them all here. If you’re reading this on the web, please subscribe here. Here’s the news this week:
CircuitPython 11.0.0-alpha.2 is Released
CircuitPython 11.0.0-alpha.2, an alpha release for 11.0.0, has been released. Further features, changes, and bug fixes will be added before the final release of 11.0.0 – Adafruit Blog and release notes GitHub.
Highlights of changes since 11.0.0-alpha.1
storage.map_file allows directly reading a file from mapped flash.
usb_host_audio.USBIn to support USB microphones.
RGBMatrix supports ABC row addressing.
USB Host Bulk IN support.
Many speedups, especially in displayio.
Many firmware size reductions.
Espressif ESP32-S31 and ESP32-P4 support.
Zephyr additions: analogio, bitbangio, neopixel_write, pwmio, rtc, and watchdog. Dynamic allocation of board buses.
Security Updates Required For Python Utilities
A security incident affecting eMudhra intermediate certificates has required removing the emSign root CA certificate from CA bundles such as “certifi”. It’s important to immediately upgrade the software packages below to at least the versions specified and rebuild container images with layer caching disabled to fetch the latest system certificates. Failure to do so could result in monster-in-the-middle (MITM) attacks against TLS clients, including python.org and pypi.org – Python Discussion Board and Cloudflare Blog.
certifi 2026.10.19
pip 26.2.2
uv 0.13.4
sigstore 4.5.1
conda 26.9.4
pixi 0.82.1
iCircuit 1.16 Adds Full RP2350 Emulation, booting CircuitPython or MicroPython
The iCircuit 1.16 emulator now offers full RP2350 emulation, PIO included, which boots stock MicroPython, wired into a live analog circuit simulator. Slide a potentiometer and Python reads voltage changes – iCircuit. Via X.
The GitHub Universe 2026 Badge Runs MicroPython
The GitHub Universe 2026 badge is a custom derivative of Pimoroni’s Tufty 2350, part of the Badger, Tufty, and Blinky digital badge crew. It retains Tufty’s RP2350B, 320×240 color LCD, 8 MB PSRAM, 16 MB flash, wireless module, battery, case lighting, light sensor, and Qw/ST expansion connector. The GitHub Universe version extends that platform with hardware designed for interactive games and badge-to-badge experiences: an onboard LSM6DS3TR-C accelerometer and gyroscope, IR transmit and receive hardware, eight capacitive touch pads (a directional pad plus Select, Back, Menu, and Home, and five physical front controls that work with the touch pads through the firmware’s orientation-aware logical input API – GitHub and Kyle Daigle’s review with video – BlueSky.
New Book: The Raspberry Pi Guide to Retro Gaming
Raspberry Pi and retro games go hand in hand, with people emulating classic consoles and computers on Raspberry Pi devices since the release of the original Raspberry Pi. A new book looks to highlight how to build retro gaming hardware and software – Raspberry Pi Press.
The Best IDE for Python: 4 Editors, From $0 to $200
The short answer for the best IDE for Python in October 2026: pick VS Code if you want one free tool that handles almost every Python job, PyCharm if you maintain a large Django, data or machine-learning codebase, Cursor if you work through AI agents all day and can live with plans that changed ten days ago, and Zed if raw responsiveness matters more than a deep plugin catalog – Shattered.
This Week’s Python Streams
Python on Hardware is all about building a cooperative ecosphere which allows contributions to be valued and to grow knowledge. Below are the streams within the last week focusing on the community.
CircuitPython Deep Dive Stream
Last Friday, Tim fills in for Scott, receives SSTV photos from space and worked on a new CircuitPython Map Tiles library.
You can see the latest video and past videos on the Adafruit YouTube channel under the Deep Dive playlist – YouTube.
Deep Dive with Tim
Last week, Tim streamed work on the CircuitPython audiotap module, FT8 receiver, and Fruit Jam Web Workflow.
You can see the latest video and past videos on the Adafruit YouTube channel under the Deep Dive playlist – YouTube.
CircuitPython Weekly Meeting
CircuitPython Weekly Meeting for October 19, 2026 (notes) on YouTube.
Project of the Week: A universal game controller firmware for CircuitPython
UniversalGC is a universal game controller firmware for CircuitPython, in the spirit of FreeJoy. Pedals, button boxes, steering wheels, flight sim panels, arcade sticks – what is wired to which pin is specified in device.json and is configured in the browser, over a WiFi access point on the device. No compiler, no flashing tool, no PC software. It runs on Raspberry Pi Pico W / Pico 2 W and ESP32-S3 (with Bluetooth LE) – GitHub.
Popular Last Week
What was the most popular, most clicked link, in last week’s newsletter? Microbe, a fast, lightweight IDE for MicroPython.
Did you know you can read past issues of this newsletter in the Adafruit Daily Archive? Check it out.
Notes from Adafruit Playground
Adafruit Playground is a place for the community to post their projects and other making tips/tricks/techniques. Ad-free, it’s an easy way to publish your work in a safe space for free.
CircuitPython drivers for the DFRobot SEN0140 10-DOF IMU – Adafruit Playground.
From Rabbit Holes to Catacombs – Programming with AI – Adafruit Playground.
News From Around the Web
picostellar by Vladimír Smitka is a planetarium for CircuitPython 11, showing 8,400 stars, constellations, the Sun, the Moon and the planets for any place and time. It runs on RP2040-class boards and up, made for the PicoPad and the Adafruit Fruit Jam (RP2350), using the picogame engine, turbo (viper) functions and flash-mapped files – GitHub.
PyMCU, which compiles Python into bare-metal firmware with no interpreter or VM, has reached its first beta. Some unmodified Adafruit CircuitPython libraries, installed straight from PyPI, now run on a real Arduino Uno: adafruit_ssd1306, with framebuf and bus_device, drives Conway’s Game of Life on a 128×64 OLED – Guide and PyPI.
Coffee Edition is a two-page newspaper that a Raspberry Pi Pico 2 W prints every morning. A Claude Code routine writes the issue overnight and GitHub Actions checks every page; the Pico, running MicroPython, pulls the job from GitHub over HTTPS, holds it until its print time and streams it to a network printer over IPP. MIT License – GitHub and write-up.
The EMF Explorer Badge Soldering Kit is a fun kit, useful for learning how to solder and exploring the hidden world of electromagnetic fields. This article shows how to add a Raspberry Pi Pico and some Adafruit sequins to animate the lit tractor beam with a CircuitPython program using the analogbufio library to trigger the animation when a magnetic field is detected – Instructables.
Python 3.15.1, 3.14.9 and 3.13.17 are out. They all upgrade the bundled pip to version 26.2.2, which includes certifi 2026.10.19 to address the eMudhra / emSign CA certificate security incident – Python Insider Blog.
Wikis: Relaunched! – PSF News.
Mark your calendars! PSF Board office hours for the year ahead – PSF News.
Ariadne is a rover built by a four-person University of Southampton team that spots gates made of printed marker cards with a camera, drives through them and counts each one. A Raspberry Pi 4 does the vision in Python with OpenCV, with no neural network, and sends steering letters over UART to a Raspberry Pi Pico (RP2040) running C++ motor firmware – GitHub and YouTube.
Student Aadhiswar Saravanan built a four-wheel Mecanum robot for IITM School Connect that can drive sideways, diagonally and spin in place without turning its chassis. A Raspberry Pi Pico WH running MicroPython drives the wheels through two L298N motor drivers – YouTube.
Michael Kennedy and a panel of Calvin Hendryx-Parker, Pat Decker, Reuven Lerner and Sydney Runkle compare the Python tools they would still pick in 2026, from editors and terminals to databases and hosting, and how AI has changed those choices – Talk Python To Me.
John Gallaugher follows up on his October 12 post in last week’s issue, where a MAX98357 DAC and amplifier combo board looked like the simplest audio setup for his CircuitPython class on ESP32-S3 boards. After more testing, an Adafruit PCM5102 DAC with a PAM8302 amp on 3.3 V sounded good through a 3 W, 4 ohm speaker, while two MAX98357A boards sounded poor with the same speaker and code, and he is asking for single-board combos that work better – Mastodon and last week’s post.
An ESP32-S3 running MicroPython joins an Android phone’s hotspot, reads the screen through the Mobilerun Portal app, asks a DeepSeek model what to do, and then taps and types on the phone. No PC, no ADB host, no root. The whole agent loop runs on the microcontroller in MicroPython – GitHub.
A local LoRa moisture sensor with a MicroPython client – GitHub.
An e-ink business card which can use CircuitPython – YouTube.
coXXect drives two 128 x 64 SSD1306 OLED displays from a Raspberry Pi Pico 2 (RP2350) in MicroPython, each on its own I2C bus. The exercises update the displays first one after the other, then at the same time, with one handled in the main thread and the other in a background thread – coXXect.
An STM32F746G-DISCO board using MicroPython and a Korean GUI (LVGL) – YouTube. (Korean MicroPython과 한글 GUI(LVGL)을 사용한 STM32F746G-DISCO 보드)
A live UK train departure board with Pimoroni Presto and MicroPython – YouTube.
Anthropic used Claude to review 25 open source projects written in C, C++, Java, PHP and Python, more than five million lines of code, and reported nearly 500 security issues, including code reachable before login, setting switch security controls off when combined, and one flaw that went unnoticed for 21 years. Anthropic argues that defenders should shrink the code exposed by default rather than chase bugs one at a time – TechRadar.
Instructables user KarimTamerSalama designs a titanium capsule for recovering data and telemetry from the deep sea. An ESP32 running MicroPython watches a pressure sensor and opens a solenoid valve to start the rescue once it passes a set depth. Instructables shares the schematic, the MicroPython code, a research paper and 3D CAD files for the housing – Instructables.
The M5Stack Firmware Simulation and Review Platform runs 14 M5Stack devices, mostly ESP32-S3 models plus ESP32-C6, Core2 and Tab5, in QEMU on a PC, so firmware can be flashed, booted, viewed and tested without the hardware. The simulator is written in Python, and UIFlow2, M5Stack’s MicroPython-based firmware, is the best tested, with ESP-IDF, Arduino and other MicroPython images also supported. It is an unofficial project with documentation in Chinese – GitHub.
Stefan Rohringer’s Magnetic-Fin-Gripper gives Seeed’s reBot DevArm soft TPU Fin-Ray fingers with a magnet in each lamella and adds an Adafruit MLX90393 magnetometer so the gripper can feel when it touches something, gently enough to hold a grape or a tiny SMD part. A Raspberry Pi Pico (RP2040) running MicroPython reads the four sensors and detects contact, and Python tools on the PC show the readings live – GitHub.
Carlos Tangerino’s msgpackc is a MessagePack serializer for MicroPython written in C as a user module, a drop-in replacement for Peter Hinch’s pure-Python umsgpack with the same API and the same bytes on the wire. In his benchmarks it packs data 76 to 123 times faster and unpacks 20 to 25 times faster on ESP32 boards while allocating far less memory, and it is tested on the ESP32, S3, C3, C6 and P4 with MicroPython 1.29 – GitHub and MicroPython discussion.
ROBO STEAM ACADEMY, an EU Erasmus+ education project, posted ready-to-run MicroPython competition programs for its PicoBot, a robot built on the Raspberry Pi Pico W or Pico 2 W. In the line-following event the robot tracks the line with five sensors, counts laps at a marker line and stops after the number of laps the competition server sends it over Wi-Fi. Sibling repositories cover object manipulation, joystick control and robot registration – GitHub and Teachers’ Toolkit.
TurboPython is a high-performance dialect of Python, compiled through C++ to a native binary. It combines Python’s syntax with an ownership model that gives memory safety and predictable performance: no garbage collector, no automatic reference counting and no GIL – tpy-lang.org. Via X.
New
A rotary encoder with a 1.8-inch touch display gets an upgrade to the ESP32-S31 SoC – CNX.
LILYGO’s T-Halow P4 is an 80 x 22 mm M.2 card that pairs an Espressif ESP32-P4 with an ESP32-C6 for Wi-Fi 6 and Bluetooth 5, and a Taixin Wi-Fi HaLow module that reaches up to 1.2 km, plus MIPI camera and display connectors. LILYGO’s examples use ESP-IDF; MicroPython has ESP32-P4 builds, but support for this board isn’t stated. It sells for $26.57 to $36.98 – CNX.
New Boards Supported by CircuitPython
The number of supported microcontrollers and Single Board Computers (SBC) grows every week. This section outlines which boards have been included in CircuitPython or added to CircuitPython.org.
This week there were three new boards added:
ESP32-C5 1.47inch Display Development Board – Waveshare
ESP32-S3-Touch-LCD-1.69 – Waveshare
Generic ESP32S3 SuperMini – Generic
Note: For non-Adafruit boards, please use the support forums of the board manufacturer for assistance, as Adafruit does not have the hardware to assist in troubleshooting.
Looking to add a new board to CircuitPython? It’s highly encouraged! Adafruit has four guides to help you do so:
How to Add a New Board to CircuitPython
How to add a New Board to the circuitpython.org website
Adding a Single Board Computer to PlatformDetect for Blinka
Adding a Single Board Computer to Blinka
New Adafruit Learning System Guides
The Adafruit Learning System has over 3,200 free guides for learning skills and building projects including using Python.
Crankfruit from John Park
Fruit Jam SSTV Receiver from Tim C
CircuitPython Text to Speech from Mikey Sklar and Anne Barela
Supernova POV Pixel Poi V2 with Wireless Controller from Erin St Blaine
CircuitPython Libraries
The CircuitPython library numbers are continually increasing, while existing ones continue to be updated. Here we provide library numbers and updates!
To get the latest Adafruit libraries, download the Adafruit CircuitPython Library Bundle. To get the latest community contributed libraries, download the CircuitPython Community Bundle.
If you’d like to contribute to the CircuitPython project on the Python side of things, the libraries are a great place to start. Check out the CircuitPython.org Contributing page. If you’re interested in reviewing, check out Open Pull Requests. If you’d like to contribute code or documentation, check out Open Issues. We have a guide on contributing to CircuitPython with Git and GitHub, and you can find us in the #help-with-circuitpython and #circuitpython-dev channels on the Adafruit Discord.
You can check out this list of all the Adafruit
https://blog.adafruit.com/2026/10/27/icymi-circuitpython-11-0-0-alpha-2-is-a-huge-update-internet-security-issues-abound-and-more/
https://cdn-blog.adafruit.com/uploads/2026/10/20261012icymi.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/cp11sm.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/20261026cert.jpg
#rss #feeds #linksharing #qwibbit

2026-10-27 14:21:28 UTC

Train a Balance Bot With Reinforcement Learning
Teach a robot to balance, using reinforcement learning in simulation just like the big labs.
The post Train a Balance Bot With Reinforcement Learning appeared first on Make: DIY Projects and Ideas for Makers.
https://makezine.com/article/technology/robotics/train-a-balance-bot-with-reinforcement-learning/
https://i0.wp.com/makezine.com/wp-content/uploads/2026/10/Reinforcement-Learning-3.jpg?fit=750%2C500&ssl=1
#reinforcementlearning
#rss #feeds #linksharing #qwibbit

2026-10-27 13:44:06 UTC

SIMD-accelerated Machine Vision on an ESP32-S3
Recently [shraiwi] decided to have a bit of good nerdy fun and implement the FAST machine vision algorithm on an ESP32-S3 using its SIMD ISA. This involves using the assembly instructions for the ISA, making for an exciting opportunity to become familiar with this part of this Xtensa Lx7-based twin-core MCU.
The Features from Accelerated Segment Test (FAST) algorithm is a corner detection method that can determine with reasonable accuracy and in real-time whether a given input frame contains said corners which thus may correspond to objects and other characteristics worthy of note. This is essential for machine vision, with machine learning able to bump up its recognition accuracy even more.
Implementing this algorithm on the ESP32-S3 proved to be a bit of a challenge due to somewhat limited SIMD ISA. Missing instructions included things like comparisons between unsigned byte values, and there is no support for direct misaligned reads.
All of these required some creative coding to work around, but in the end the ESP32-S3 running at 240 MHz was able to process a VGA stream in real-time at 30 FPS. This means about a 2x speed-up over a naive implementation using only non-SIMD instructions.
If you want to play along at home, the Platform IO project is made available on GitHub.
https://hackaday.com/2026/10/27/simd-accelerated-machine-vision-on-an-esp32-s3/
https://hackaday.com/wp-content/uploads/2016/02/computersaretakingover.jpg?w=800
https://hackaday.com/wp-content/uploads/2016/02/computersaretakingover.jpg
#machinevision #isa #segmenttest #acceleratedsegment #fast #mcu #xtensa #fps #vga
#rss #feeds #linksharing #qwibbit

2026-10-27 13:11:49 UTC

Boar BBS: a telnet and SSH bulletin board with mail, boards, chat and door games
BBS
Developer rh1tech has published Boar BBS on GitHub, a bulletin board system that callers reach over telnet or SSH. It has ANSI color, CP437 block art, hotkey menus, private mail, public message boards, live chat, door games and a oneliner wall, along with sysop tools.
Boar is written in Go and builds to a single binary. All data lives in one SQLite file through a pure-Go driver, so no C compiler is needed. Type NEW at the handle prompt to register. The first account becomes the sysop, and later accounts are read-only until a sysop approves them.
Callers can register up to five SSH public keys for passwordless login. Doors are external programs listed in a JSON file, and the BBS writes DOOR.SYS and DORINFO1.DEF before handing the caller over. Classic DOS doors such as LORD and TradeWars 2002 are meant to run under DOSBox-X over an emulated serial port, though the author notes nobody has tried a real DOS door yet. There is also a FidoNet layer and an optional web-based sysop menu. The code is GPL v3.
See more on GitHub.
https://blog.adafruit.com/2026/10/26/boar-bbs-a-telnet-and-ssh-bulletin-board-with-mail-boards-chat-and-door-games/
https://cdn-blog.adafruit.com/uploads/2026/10/aa-17.png
#boarbbs #bulletinboard #ssh #doorgames #bbsdeveloper #mail #telnet #chat #dos #github
#rss #feeds #linksharing #qwibbit

2026-10-27 12:36:10 UTC

Omnibot Reborn: Giving a 1984 Robot Butler the Brain It Was Promised
In 1984, Tomy sold a toy robot that promised a domestic future it couldn’t quite deliver. Forty years later, a maker in Miami gave it vision, a voice, and just enough intelligence to finally pull it off.
The post Omnibot Reborn: Giving a 1984 Robot Butler the Brain It Was Promised appeared first on Make: DIY Projects and Ideas for Makers.
https://makezine.com/article/technology/robotics/omnibot-reborn-giving-a-1984-robot-butler-the-brain-it-was-promised/
https://i0.wp.com/makezine.com/wp-content/uploads/2026/10/omnibot-ringo-hero.jpg?fit=750%2C424&ssl=1
#promised
#rss #feeds #linksharing #qwibbit

2026-10-27 11:28:40 UTC

ESP_MOVIE: Movie playback library for ESP32 series
Tomino Shun has published ESP_MOVIE on GitHub, a movie playback library for the ESP32 series. It plays Motion JPEG video from AVI files along with MP3 audio.
The library drives displays over an Intel 8080 8-bit parallel interface using DMA transfer. SPI is not supported. Color formats are RGB565 and BGR565. A handful of display controllers have been tested, and other MIPI DCS compatible controllers may work without being confirmed.
The examples folder ships with sample Motion JPEG (AVI), MP3 and JPEG files so the library can be tried right away.
See more on GitHub.
https://blog.adafruit.com/2026/10/26/esp_movie-movie-playback-library-for-esp32-series/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-102.jpg
#rss #feeds #linksharing #qwibbit

2026-10-27 09:46:28 UTC

An Atari Steeplechase arcade cabinet restoration
Tony at The Arcade Blogger has posted a follow-up on an Atari Steeplechase cabinet he pulled out of a condemned building in France during a group rescue trip with other arcade collectors. The machine is the Atari Europe version, which uses a different cabinet shape than the more angular USA release.
Tony cleaned it up and started work, then sold it after taking on too many projects. The cabinet passed through three owners, each doing a little more to get it running. It ended up with Jon Turner of Pixel Busters arcade in Stoke on Trent in the UK, who finished the restoration and put it on the arcade floor.
Jon’s video walks through the work he did and ends with a tour of Pixel Busters. Steeplechase is a multiplayer game, so a public arcade suits it. At a recent UKVAC meet-up, it was the centerpiece of a weekend competition with a trophy, and it stayed busy the whole time.
See the video below and more on arcadeblogger.com.
https://blog.adafruit.com/2026/10/26/an-atari-steeplechase-arcade-cabinet-restoration/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-103.jpg
#ataristeeplechase #arcade #pixelbusters #cabinet #restoration #jonturner #tony #usa #stoke #trent
#rss #feeds #linksharing #qwibbit

2026-10-27 08:36:59 UTC

ESP32 Rotary Display Makes Ideal Timer
We’re big fans of pushing hardware into situations it wasn’t designed for here at Hackaday, but sometimes you’ve got to appreciate a nicely designed gadget doing more or less exactly what it was intended for — especially when it’s courtesy of code that’s freely available for you to run and hack on however you like.
That’s precisely what [mircemk] has done with their “Universal Timer” project. The 2.1 inch CrowPanel “Rotary Display” at the heart of the build combines an ESP32-S3 with a 480×480 round touch screen display and a rotary encoder.
The all-in-one device — clearly meant to be reminiscent of the Nest thermostat and similar commercial offerings — is technically all you need, but in this case it’s been joined by a PCF8574 I2C I/O expander which in turn is used to drive a buzzer that provides a bit of audio feedback at the end of the countdown.
With the code [mircemk] has provided flashed onto the board, the rotary encoder ring built into the housing makes for an exceptionally intuitive input for setting the desired time. It’s a bit like a high-tech version of the classic kitchen timer, as shown in the video below, you simply twist the ring and the graphics on the display rotate accordingly. Unlike grandma’s clockwork timer of old however, this one can change color as it nears zero, which makes it easier to estimate how much time remains from across the room.
As the popularity of smartwatches has brought the cost of these circular displays down, we’ve started to see some very slick projects utilizing them. The various efforts to turn them into desktop “radar” displays for nearby flights are a particular favorite.
https://hackaday.com/2026/10/27/esp32-rotary-display-makes-ideal-timer/
https://hackaday.com/wp-content/uploads/2026/10/roundtimer_feat.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/roundtimer_detail.jpg?w=400
https://hackaday.com/wp-content/uploads/2026/10/roundtimer_feat.jpg
#rotarydisplay #timer #universaltimer #hackaday
#rss #feeds #linksharing #qwibbit

2026-10-27 08:04:37 UTC

Amateur astronomer harnesses AI to find a possible hidden exoplanet
Adam Kovac, writing for Scientific American, reports on an amateur astronomer who used AI agents to pull a possible exoplanet out of public NASA data. Pavel Rabtsevich, a product manager based in Spain, ran a custom machine learning setup over more than 126,000 target stars observed by the Transiting Exoplanet Survey Satellite. It flagged TIC 4206066, a star about 116 light-years away in Orion that dims for roughly two hours every three days.
Digging through the TESS archives turned up 22 more dimming events. If confirmed, the planet would be a super-Earth about 1.4 times the radius of our planet, with a surface temperature near 1,000 degrees Fahrenheit. Rabtsevich is careful about the claim. Some 2018 dips line up with moments when TESS fired its thrusters.
He says the models wrote the code, ran it and checked each other’s work, while the questions and decisions were his. The signal was not entirely new: a TESS detection filter caught it in 2020 and rejected it for lack of evidence. The TESS team now plans to reexamine the star in November.
See more at scientificamerican.com.
https://blog.adafruit.com/2026/10/26/amateur-astronomer-harnesses-ai-to-find-a-possible-hidden-exoplanet/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-104.jpg
#amateurastronomer #exoplanet #scientificamerican #tess #transitingexoplanet #surveysatellite #adamkovac #rabtsevich #spain #ai
#rss #feeds #linksharing #qwibbit

2026-10-27 06:22:33 UTC

The Lightbulb Computer: reimagining spatial & ambient computing
A design project published at lightbulbcomputer.com proposes an alternative to smart glasses and headsets: a speculative device called the Lightbulb Computer. It combines a projector with computer vision in the shape of a large light bulb, so it can screw into any Edison socket in a wall or ceiling, or sit in a portable lamp base.
The device responds to voice commands, sees where a person points, analyzes what it sees, and projects content onto real surfaces. The demos include recipe widgets and timers pinned to kitchen counters, a wall-sized map two people can pan and scroll together, photos sent over from a phone, a family checklist in the hallway, and smart home controls triggered by pointing at a device instead of naming it.
All the videos come from a real but bulky prototype setup, with no editing or AI generation. The designer says consumer hardware is not quite there yet, but projectors are getting brighter and smaller, and vision models are fast enough to read a bookshelf in milliseconds. Privacy would be handled with on-device processing, a hard-wired indicator light, and a physical camera cover.
See the video below and more at lightbulbcomputer.com.
https://blog.adafruit.com/2026/10/26/the-lightbulb-computer-reimagining-spatial-ambient-computing/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-105.jpg
#lightbulbcomputer
#rss #feeds #linksharing #qwibbit

2026-10-27 05:47:53 UTC

The Oldest Windows App To Still Run On WIndows 11
In the open source world we are used to software being compiled from source for our particular distro, so while in a few cases an ancient release may still be in use, it’s just going to run on the latest distro version. But in the Windows world it’s rare for software to come with the source, so you’re left with a binary that will only run if your Windows version has the right APIs for it. Since the more recent versions of Windows dropped 16-bit support a while back, that means there must be a hard date set on the earliest Windows GUI application that can still run today. [Enlyth] decided to investigate.
Given that the earliest API supported in WIndows 11 is the 32-bit version, the hunt led straight to either the first Windows NT release and ancestor of Windows 11, or the Win32s extension for WIndows 3.1. Thus a 1993 Win32S version of Freecell runs happily, but that want’s the end of the trail. Somewhere in the pre-release builds of Windows NT 3.1 would be the requisite binary, but there’s a snag. Early Windows NT 3.1 APIs were incompatible with later ones. This led through a lot of crashing binaries to a November 1992 version of the CD player app, that ran because it called a DLL which happens to still be present. The need for another DLL to emulate a CD drive speaks volumes about the progress of the PC world, back then they were the last word in storage but who’s got one now?
That’s the earliest official binary to run, but the story’s not quite over. Windows 11 may not have a VDM to run 16-bit apps, but there’s a WINE VDM for that. Behold, Reversi from Windows 1.01 in November 1985, in Windows 11. Your ancient software may yet be saved.
https://hackaday.com/2026/10/26/the-oldest-windows-app-to-still-run-on-windows-11/
https://hackaday.com/wp-content/uploads/2026/10/oldest-winapp-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/oldest-winapp-featured.jpg
#rss #feeds #linksharing #qwibbit

2026-10-27 05:12:16 UTC

Making 1,750 programmable PCB badges for Canada’s biggest hackathon
Nick Ficara, writing at va3ndf.com, documented how his team replaced the cardstock name tag at Hack the North with a programmable circuit board. Each badge carries an ESP32, a color screen, buttons, an NFC reader, a WS2812B LED and two AA cells. A Lua runtime, a browser-based code editor and an on-device shell let attendees write their own apps.
The design went through four spins at JLCPCB. An EVT with a 10uF capacitor fitted where a 10uH inductor belonged. A screen ribbon the factory said was too dense to solder. An NFC chip that turned out to be a tag, not a reader. A 50 unit PVT were backwards batteries made smoke and two chips arrived rotated, leaving 12 of the first dozen boards dead on arrival.
A reverse-polarity FET went straight into the production run untested on a full board. The final order was 1,750 assembled badges plus 750 blanks, about $20,300, or roughly $11.60 per populated badge against a $5 pitch. Hackers built Among Us over a mesh network, a Pokédex of people and Tux Racer controllers. The hardware, firmware and a WebAssembly emulator are open source.
See more at va3ndf.com and content on GitHub.
https://blog.adafruit.com/2026/10/26/making-1750-programmable-pcb-badges-for-canadas-biggest-hackathon/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-106.jpg
#pcb #nickficara #nfc #tuxracer #lua #jlcpcb
#rss #feeds #linksharing #qwibbit

2026-10-27 04:06:04 UTC

keybytes: a truly modular keyboard
Nathan, @NotARoomba on GitHub, designed Keybytes, a keyboard where each key is its own board. Everything was designed in KiCad.
There are two board types, both 1u at 19.05mm x 19.05mm. The Keybit holds one Cherry MX switch and a CH32V003 microcontroller. Pogo pins on all four sides carry 3.3V, ground and I2C, so a Keybit can connect to the main board or to other Keybits. Pads at the corners handle programming.
The Keyword is the main board the Keybits attach to. It is two PCBs stacked together. The top carries an STM32WB55RGV6, an antenna and the flash. The bottom carries USB-C, the battery charger and a buck-boost converter. Three pogo pins on top program the Keybits.
The cases were drawn in Onshape and the STEP files are in the cad folder. The project is MIT licensed.
See more on GitHub.
https://blog.adafruit.com/2026/10/26/keybytes-a-truly-modular-keyboard/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-107.jpg
#keybytes #keyboard #github #pogo #step #mit #notaroomba
#rss #feeds #linksharing #qwibbit

2026-10-27 02:21:06 UTC

In Praise Of A Legendary Power Transistor
There are some devices which achieve electronic immortality, it’s likely that you have used a few of them yourself. The 555 timer of course, or the 741 op-amp. [ElectronicsNotes] is here with another candidate that might not have been on your mind as you read the previous sentences, and it’s a transistor. The 2N3055 is an NPN power transistor, no, THE NPN power transistor, that has found its way into an astounding array of devices over the last six decades or more.
For such a ubiquitous device one might imagine that there’s not much new to know, but the video delivers on that front. Here as well as probably for you the 3055 has always been an epitaxial device whose quirks you likely know well, but originally it was something different. It used the hometaxial construction process on its launch in the early 1960s, but in the mid 1970s it was replaced by a version with the same capabilities but using the epitaxial process. The consequent higher Ft required modifications to circuits using the device to stop unwanted oscillation.
Where this is being written there are several 2N3055s, in the by now rather old office audio amplifier, in a bench power supply, and probably elsewhere too. It’s been superseded in many ways and its TO3 case now feels antiquated, but it will probably never entirely go away. Meanwhile if you’d like to read about another iconic 1960s device that never went away, we have you covered.
Header: a really early example. Eule4404, CC BY-SA 4.0
https://hackaday.com/2026/10/26/in-praise-of-a-legendary-power-transistor/
https://hackaday.com/wp-content/uploads/2026/10/2n3055-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/2n3055-featured.jpg
#powertransistor #npn
#rss #feeds #linksharing #qwibbit

2026-10-27 02:10:32 UTC

A pixel art fish tank for the Interstate 75 matrix LED controller for two panel displays
NickyMoo has published an animated pixel art aquarium on GitHub that runs on the Pimoroni Interstate 75 W (RP2350) and drives two 64 x 64 HUB75 panels side by side for a 128 x 64 scene. It needs no internet, no account, and no network code.
The tank holds resident fish and visitors, jellyfish, a night anglerfish and a ghost, submarines, bubbles, animated foliage and coral, a snail, a hermit crab, an oyster with a pearl, and a treasure chest. Feeding animations start at local :15 and :45 and run for 28 seconds. Day and night palettes switch automatically, with night hours set to 20:00 to 06:59. Target frame rate is 15 FPS.
Holding B shows or hides a 24-hour clock in the top-left corner, drawn in front of the aquarium. The RTC keeps local wall time only, with no timezone or daylight saving handling, and it needs resetting after a power loss. There is also a Tkinter and Pillow emulator, emulator.py, so the scene can be previewed on a computer without hardware. The code is MIT licensed.
See this post on Reddit and more on GitHub.
https://blog.adafruit.com/2026/10/26/a-pixel-art-fish-tank-for-the-interstate-75-matrix-led-controller-for-two-panel-displays/
https://cdn-blog.adafruit.com/uploads/2026/10/x-1.gif
#pixelart #pimoroniinterstate #led #two #github #fps #rtc
#rss #feeds #linksharing #qwibbit

2026-10-27 01:05:42 UTC

Enable Resizable BAR on Unsupported Motherboards
Recently [Rod Burlamaqui] released the arc-rebar project on GitHub, enabling Intel GPUs to work significantly more efficiently if the system’s mainboard does not support resizable BAR. It does require a Debian or Ubuntu installation and of course a supported Intel GPU.
Although the resizable base address register (ReBAR) feature has been part of the PCIe specification for a while, its use was quite limited until Intel released its Arc series of graphic cards. These use this feature to map much more of the GPU’s video RAM (VRAM) into the PC’s address space than the standard 256 MB, assuming that the system is capable of decoding addresses above 4 GB, i.e. allow for 64-bit BARs.
For GPU manufacturers like AMD and Nvidia this wasn’t so much of an issue as their GPU designs developed in a world where ReBAR didn’t exist, while Intel’s new GPU generations were designed with ReBAR as a core feature, which naturally cripples performance if the mainboard does not have it enabled during PCIe bus enumeration.
This initramfs-based fix runs before the GPU driver loads and performs the requisite BAR configuration. In testing with an Intel Arc B580 GPU on a 2015-era Intel Xeon mainboard the difference between the default and the fixed bandwidth was a bump from a pitiful 15 GB/s to a respectable 392 GB/s, showing how this one fix can breathe new life into older systems.
https://hackaday.com/2026/10/26/enable-resizable-bar-on-unsupported-motherboards/
https://hackaday.com/wp-content/uploads/2026/10/arc-rebar_fix_rod_burlamaqui_github.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/arc-rebar_fix_rod_burlamaqui_github.png
#resizablebar #gpu #intel #rodburlamaqui #arc #rebar
#rss #feeds #linksharing #qwibbit

2026-10-27 00:31:24 UTC

EInk launches latest version of color ePaper platform E Ink Kaleido 4
E Ink announced Kaleido 4, the newest generation of its color ePaper platform, in a press release from Billerica, Massachusetts. Compared to the previous generation, Kaleido 4 doubles color gamut volume to more than 40K, raises white reflectance by 15%, and improves contrast by 50%. New algorithms push video playback to 18 frames per second.
The panel uses an oxide TFT backplane that supports higher driving voltages and faster refresh. E Ink says the result reduces the grainy look that color ePaper has had, and handles charts, presentations and illustrations as well as text.
The first shipping product with the display is the M10C II smart ePaper notebook from Hanvon Technology. Hanvon pairs the panel with its own timing controller and pressure floating technology for 27% faster page turning and scrolling, plus a redesigned front light. The included digital pen is wireless and battery free with 8,192 pressure levels, and the writing surface is micro-etched tempered glass.
See more at eink.com.
https://blog.adafruit.com/2026/10/26/eink-launches-latest-version-of-color-epaper-platform-e-ink-kaleido-4/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-109.jpg
#inkkaleido #colorepaper #epaperplatform #hanvon #technology #massachusetts #tft
#rss #feeds #linksharing #qwibbit

2026-10-26 22:53:26 UTC

GitHub – ankur608/ArduinoUnoQ_AdafruitTouch
ankur608 published an Arduino library on GitHub for using the Adafruit 2.8″ TFT Touch Shield v2 with capacitive touch (PID 1947) on the Arduino UNO Q, specifically the arduino_uno_q_stm32u585xx core.
The shield routes SPI through the 6-pin ICSP header rather than pins 11 through 13. On the UNO Q’s STM32U585, those land on MOSI 23, MISO 22 and SCK 24, so the usual sketches do not work without remapping. The library handles that, sets up the FT6206 capacitive touch controller over I2C, and reduces the setup to a one-line call.
It also fixes the rotation problem. The FT6206 reports coordinates in portrait at 240 x 320. The library’s screen.getPoint() computes the transformation for whichever rotation is selected, so touch points match what is on screen. Installation is by cloning into the Arduino libraries directory or pointing the IDE at the Git URL, plus the core Adafruit driver dependencies. Examples appear under File, Examples. The license is MIT.
See more on GitHub.
https://blog.adafruit.com/2026/10/26/github-ankur608-arduinounoq_adafruittouch-2/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-110.jpg
#github #uno #arduinouno #touch #tfttouch #shield #giturl #examples #pid #icsp
#rss #feeds #linksharing #qwibbit

2026-10-26 21:42:31 UTC

A wakeboarding winch build log
Gal, writing at Mare & Gal Electronics, documented an electric drum winch built to tow a wakeboarder. The 12 kW motor and the 24S10P battery pack, about 100 V charged, were pulled from a scrapped Awake board. The frame, drum, belt drive, rope guide, electronics and firmware are all his own work.
The drum core is 200 mm across and 120 mm wide, 3D printed, with 6 mm laser-cut aluminum flanges. An HTD 5M belt gives a 7.1:1 reduction, good for roughly 39 km/h rope speed and about 1170 N of pull. The rope is 300 m of 3 mm Dyneema SK-75 at 0.87 EUR per meter, the single biggest cost in the build.
With 13 to 17 layers of rope on the drum, a level wind was needed, so the winch has a motorized rope guide on an SFU1204 ball screw driven by a NEMA 23 stepper. A custom 4-layer board steps the 100 V pack down to 48 V and reads the VESC tachometer over CAN at 250 kbit/s. One drum turn moves the carriage 3 mm. Total cost was about 700 EUR.
See more at e.pavlin.si.
https://blog.adafruit.com/2026/10/26/a-wakeboarding-winch-build-log/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-111.jpg
#galelectronics #eur #mare #htd #dyneema #nema #vesc
#rss #feeds #linksharing #qwibbit

2026-10-26 20:57:36 UTC

Practice Japanese on an Inkplate 4Tempera eInk Device
Learning a new natural language can be a daunting proposition at the best of times, with repetition and immersion generally considered to be the best ways to build up not only vocabulary but also that innate sense for grammar and cultural details that sneak into every spoken language. Flash cards are one way to help with vocabulary and sentence building, such as [Peter Hraska]’s Enkiplate project that uses the Inkplate 4Tempera being an interesting alternative to lugging a stack of cards with you.
Although the software also works in the browser, using the Inkplate or similar device means that you can keep it with you while it keeps track of your progress in learning the shown cards, with a starting pace of 12 cards per day to learn. It also shows you calendar items for that day and the weather using an online weather service.
Starting from basic kana, i.e. the two phonetic writing systems, the difficulty is slowly ramped up to cover kanji and then sentences. Due to the limitations of the 4Tempera’s ESP32-WROVER-E module’s local storage up to 16 flash cards can be stored at a time, with an application on a PC being necessary to obtain new cards.
https://hackaday.com/2026/10/26/practice-japanese-on-an-inkplate-4tempera-eink-device/
https://hackaday.com/wp-content/uploads/2026/10/enkiplate_epaper_virpo_peter_hraska_github.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/enkiplate_epaper_virpo_peter_hraska_github.jpg
#practicejapanese #inkplate #device #peterhraska #eink #starting
#rss #feeds #linksharing #qwibbit

2026-10-26 19:16:37 UTC

Arduino Engine Runs Many Games
A few years ago, [Smashcat] ported a ZX Spectrum game called Manic Miner to the Arduino Uno. The Arduino has less memory than the original Spectrum did, so doing all this on an 8-bit microcontroller was no easy lift. Since then, parts of this original port have been adapted to produce a game engine, allowing [Smashcat] to port several other games to the Arduino Uno as well.
The engine is able to host a 2D map with the ability to scroll, at a resolution of 256×256, as well as up to nine sprites at the same time. The graphics are locked to 50 FPS, but only with a real Arduino Uno that has a crystal oscillator. Some replica boards do not have a timekeeping chip accurate enough to replicate the video signal, which is done without a framebuffer. That signal, as well as two PWM audio channels, are still generated directly as well, with only a few resistors needed to hook everything up to a monitor and a controller, including the option of using an NES controller.
With all of that running on the Arduino and it hooked up to the daughterboard that provides the controller interface as well as the resistors for the video signal to function and a driver for a speaker, the system now runs the original Manic Miner as well as three other games: Scramble, Space Invaders, and Pac Man.
The engine and the rest of the code are available on a GitHub page as well, and there’s even a WebAssembly version available to run various pieces of the software without the specific hardware. The original ZX Spectrum was an interesting machine too that still inspires builds like this, despite it being well over 40 years old now.
https://hackaday.com/2026/10/26/arduino-engine-runs-many-games/
https://hackaday.com/wp-content/uploads/2026/10/zx-arduino-main.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/zx-arduino-main.jpg
#arduinouno #manicminer #games #smashcat #spaceinvaders #pacman
#rss #feeds #linksharing #qwibbit

2026-10-26 17:35:52 UTC

BMW i3 Mod Brings Small Trucks to the EV Future
Trucks are handy, especially if you’ve got messy or dirty loads, but there aren’t a lot of options if you want a small electric pickup yet. [Michael Pick] decided to convert a BMW i3 into a utility vehicle.
After getting a new 12 V battery and cleaning the car up, [Pick] proceeded to disassemble the interior and remove the hatch from the car. Once he could look at the bones, he planned out the best places for the cut lines and removed the back half of the cabin.
The bed is built from plywood coated in penetrating epoxy and bedliner for weatherproofing, and special care was taken to seal the interface between the cabin and bed as the main electronics for the vehicle are housed in a compartment directly below. The taillight electronics were rehoused as the OEM lenses were too large to fit next to the tailgate opening.
The i3 has graced these pages before with a battery upgrade, and we’d be remiss not to remind you of the most famous EV to truck conversion, Truckla.
https://hackaday.com/2026/10/26/bmw-i3-mod-brings-small-trucks-to-the-ev-future/
https://hackaday.com/wp-content/uploads/2026/10/Gas-Prices-Are-Insane-So-I-Built-My-Own-Electric-Truck-0-39-45.jpeg?w=800
https://hackaday.com/wp-content/uploads/2026/10/Gas-Prices-Are-Insane-So-I-Built-My-Own-Electric-Truck-0-39-45.jpeg
#modbrings #bringssmall #smalltrucks #bmw #future #michaelpick #oem
#rss #feeds #linksharing #qwibbit

2026-10-26 15:57:12 UTC

The Fascinating World of IrDA and Other Infrared Protocols
Infrared (IR) communication technologies are probably one of the most influential, yet also one of the least flashiest. The fact that IR communication tends to be highly directional and often limited to low data rate leads many people to scoff at it, deeming it barely worthy of more than making TV remotes work, perhaps along with some unloved industrial gear like the IR interface of electrical meters.
This is a shame, because TV remotes are a good example of why sometimes you want something that is directional, and anyone who has battled with Bluetooth pairing can attest to the value of things simply working by pointing it at the device. IR protocols also have the advantage of inherent privacy protection as walls and other obstacles will block the signal, unlike that of an exploitable Bluetooth device which happily advertises to your neighbors and passersby.
For reasons like the above – as well as their simplicity and hackability – IR protocols are worthy of a detailed look.
Remote Control
Naturally, one of the oldest uses of consumer IR protocols is that of the venerable IR remote control. Initially TVs used wired and ultrasonic remote controls, with the latter using simple ultrasonic tones to transfer a command, but with IR protocols and the advent of cheap MCUs it became possible to create extensive communication protocols. Of these the NEC, Sony IR (SIRC) and Philips protocols are probably the most well-known and most used.
These use an approximately 38 kHz carrier, with the common NEC protocol using pulse distance encoding – a form of amplitude-shift keying – and the Philips RC-5 protocol using Manchester encoding. Within this encoding, these protocols define various bit fields and other values that can be used by a receiver to determine whether it’s being targeted, and if so what command the user wishes to have performed.
When it comes to those cheap-and-cheerful remotes that you get with just about any RGB light strip and others gadgets these days, they tend to use the same NEC protocol, with many MCU-based projects around that can control these gadgets directly with a simple IR LED.
This STM32F0-based project by [eleksaggr] on GitHub that targets the common 24-key RGB remotes. This Infrared Remote Control Implementation application note by Texas Instruments for the MSP430, which contains a good overview of the modulation and encoding schemes, as well as how to implement a remote control.
Many smartphones have – or used to have – an IR blaster feature that can target the same carrier frequency and a range of protocols to control just about anything that is IR remote controlled. In a world of smartphones this would theoretically mean that everyone has a universal remote in their pocket at any time, if it wasn’t for IR blasters becoming pretty rare. If your recently purchased smartphone still has an IR blaster, it’s very likely a Chinese brand, which is a shame as IR remotes are still used for so many things.
IrDA
IrDA used to transfer a file between a Thinkpad T40 and T42. (credit: nick99nack, Wikimedia)
Of course, IR remotes are quite a specific use case, but you can send a lot more than just a basic set of commands to a device. The most well-known standard here is IrDA, which stands for Infrared Data Association, the association which defined the various standards.
The basic principles behind IrDA remain effectively the same as with the remote control protocols, just designed to be capable of far higher transfer speeds. This is accomplished through various types of encoding, modulation and other techniques also observed with non-IR forms of wireless communication. Using this a range of speeds are possible, defined as:
SIR (115 kbit/s).
MIR (1 Mbit/s).
FIR (4 Mbit/s).
VFIR (16 Mb/s).
UFIR (96 Mbit/s).
Giga-IR (512 Mbit/s – 1 Gbit/s).
The IrDA protocol stack. (Credit: Fred derf, Wikimedia)
In additional a range of derived protocols exist such as IrSimple that allows for easy sharing of images between phones, printers, and displays. All of this uses generally the same IrDA software stack, though the special versions such as IrSimple optimize it to make transfers take less than a second for a 500 kB picture.
All communication generally happens in half-duplex, as the sending side tends to produce too much interference for the receiving side of the transceiver to reliably receive data. Distance between the two sides can be as much as two meters, though the lower power versions shrink that down to 20 cm or thereabouts.
Within this range of speeds you can pick whatever the device needs. Power meters, for instance, are plenty happy with the IrDA-SIR protocol, which is low-power and speed enough to bitbang on even a basic MCU in these meters with just a basic IR transceiver attached to its pins.
Power Meters
IR transceiver port on IEC 62056-enabled smart meter. (Credit: WMKrieling, Wikimedia)
The humble power meter that lurks in your utility closet or wherever else it is installed has to be shielded from whatever environment it is installed in, ergo they require some kind of low-power, low-speed wireless interface. Using nothing but an IR-transparent window on the enclosure it is then possible for a read-out device to be pressed up to said window, where it’ll quickly query the device for the necessary information.
This same feature is also found on heat meters and other types of devices where such basic read-out functionality is required. Here security is managed by not only the short-distance, line-of-sight requirement of an IR communication link, but also by having a sign-on involving an encrypted password exchange.
Although IrDA-SIR was commonly used here, these days DLMS/COSEM, also known as IEC 62056 is much more common. While radio-based forms of automatic meter reading (AMR) are also used, short-range protocols like this have a definite privacy advantage, with the line-of-sight feature meaning that the reader has to be literally in front of the meter to work, unlike with RF wireless approaches.
Whether this privacy aspect is important depends on the situation, but it’s hard to argue with the low power requirements compared to stuffing a Bluetooth or Wi-Fi module into the meter and dealing with its implications.
Game Consoles
Nintendo 3DS with Circle Pad Pro accessory installed. (Credit: Umweltschützen, Wikimedia)
Although it may seem that handheld game consoles went straight from the Game Boy’s link cable to Wi-Fi transfers on the Nintendo 3DS beyond, it featured an IR communication port. This was intended to support peripherals like the Circle Pad Pro and the Amiibo reader/writer device for the original 3DS as it did not feature the NFC reader of the New Nintendo 3DS.
As it turns out, the 3DS uses irDA-SIR for this expansion feature, with e.g. the Circle Pad Pro using a 96000 baud rate. Since this peripheral merely is there to add a second circle pad to match the built-in left one, it doesn’t need a lot of bandwidth.
In the case of the external NFC reader, this was a similar low bandwidth application where it made a lot of sense to use this same IR port to provide this new feature to older 3DS consoles, instead of making it a New 3DS-exclusive feature. Although one could have used Bluetooth for this even back then, the 3DS console did not include Bluetooth, and when looking at e.g. the Joycons of the Nintendo Switch it’s clear that they are a tad more power hungry and complex circuitry-wise.
When low-power and line-of-sight are benefits rather than a potential source of confusion of which peripheral you’re trying to pair with, it can make a lot of sense.
DIY IR Transceiver
If you’re feeling like making your own IR receiver, receiver or even transceiver solution, there are many options. Perhaps the most exciting aspect is that even if you want to use something like IrDA, this feature is often part of the UART in many MCUs. In the case of Espressif’s ESP32 MCUs, for example, you can look at its list of potential UART modes and note that you can pick IrDA as well as RS485 in addition to plain UART functionality.
There are also dedicated IrDA encoder/decoder ICs, such as the MCP2120. This gets you IrDA-SIR support for any UART interface that does not directly implement this protocol. You can also use something like the Vishay TFDU4101 IrDA transceiver that integrates everything including the IR elements into a single package.
If you’re more about messing with NEC, Sony and Philips remote control protocols, then a common part like the VS1838b provides a similar solution to the Vishay part for 38 kHz applications. This IR receiver handles all the receiving, demodulating, amplification and other tasks, leaving it to the receiving MCU to parse the received data.
This of course just barely scratches the surface of everything IR communication-related, so feel free to chime in with your own info dumps and requests for additional topics to cover.
https://hackaday.com/2026/10/26/the-fascinating-world-of-irda-and-other-infrared-protocols/
https://hackaday.com/wp-content/uploads/2026/10/Optical_IR.jpg?w=800
https://hackaday.com/wp-content/uploads/2019/06/ir-remote-thumbnail.jpg?w=400
https://hackaday.com/wp-content/uploads/2026/10/Infrared_File_Transfer.jpg?w=400
#protocols #remotecontrol #world #nec #bluetooth #rgb
#rss #feeds #linksharing #qwibbit

2026-10-26 11:54:46 UTC

Hiding Virtualization From Other Software
The Kernel-based Virtual Machine (KVM) allows Linux systems to function as hypervisors without needing any extra software, but VMs created with it don’t behave exactly like real hardware does. Sometimes that’s important, though, so [sandwich] built a tool called vfio-native that obscures the fact that software might be running in a virtual machine.
There are plenty of the ways that virtual hardware differs from bare metal. The VM may behave slightly differently for obscure instructions in ways that are measurable, it may take slightly longer to perform some tasks, or the hypervisor may simply announce itself directly. vfio-native includes some kernel patches that solve some bugs which address the different behaviors, changes the way that the kernel identifies itself, and attempts to force the CPUs to behave in ways that real hardware would behave. With all of this applied to the virtual machine, it scores a 1/85 against a VM detection tool, with a standard KVM virtual machine scoring 10/85.
For anyone looking to test this out, it’s available in the AUR for Arch Linux. Also, it’s probably worth mentioning that there are more reasons to use this than cheating at Counter-Strike. For example, security researchers testing malware need to know how that software behaves when it thinks its on real hardware, and some may behave in benign ways when confined to virtual machines. Some licensed software also may disable itself when it detects its running in a VM, which can be a nuisance for things like software controlling industrial tools which only run on operating systems that are no longer maintained or hardware that can’t be found anymore. Some other tools we’ve seen before perform similar tasks as well.
https://hackaday.com/2026/10/26/hiding-virtualization-from-other-software/
https://hackaday.com/wp-content/uploads/2017/10/computers.jpg?w=800
https://hackaday.com/wp-content/uploads/2017/10/computers.jpg
#virtualmachine #software #kvm #linux #archlinux
#rss #feeds #linksharing #qwibbit

2026-10-26 09:00:52 UTC

Hairy Armor For Combat Robot? It’s Not Terrible!
[Angus] of Maker’s Muse enjoys combat robotics, in which contenders zip about in an arena, attempting to disable one another with weapons that lift, spin, and smash. He got a funny idea a short while ago and wondered whether a stiff mane of bristles could serve as lightweight, ablative, impact resistant armor?
Just to set the stage, [Angus]’s new robot competes in the plastic antweight (or “plant”) division, in which robots are limited to 150 grams with both chassis and weapons made of plastic. In such circumstances, one can see how a mane of thick, rigid “hairs” might actually punch above its weight, so to speak.
The green shape at the bottom is a spinning weapon. The bristles cover the sides and rear.
Nothing settles a question like a good experiment, so [Angus] sat down and redesigned his latest robot to replace its outer shell with a thick wad of bristles, in the style of a 3D printed lion’s mane. Filament is bridged between the model and an outer support structure, which is cut away afterwards to expose the “hairs”.
How well did it perform? Well enough to merit further study! Where past robots got their outer shells broken up, the hairy robot seems to have come through quite intact. It seems the idea might not be as silly as it first seemed, at least in the plastic antweight division.
3D printers have been fantastic in the field of combat robotics. First they were great because they made custom parts easier and more accessible to hobbyists, but things have evolved more since then. Now folks compete by putting motors and electronics inside almost entirely 3D printed robots. There’s never been a better time to get into combat robotics, and experiment with unorthodox designs.
If you want to try a hairy robot for yourself, be sure to watch the followup in which [Angus] improves the hair-generating process considerably.
https://hackaday.com/2026/10/26/hairy-armor-for-combat-robot-its-not-terrible/
https://hackaday.com/wp-content/uploads/2026/10/I-made-a-HAIRY-combat-robot-in-48hrs-26-38-screenshot.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/I-made-a-HAIRY-combat-robot-in-48hrs-19-53-screenshot-thumb.png?w=400
https://hackaday.com/wp-content/uploads/2026/10/I-made-a-HAIRY-combat-robot-in-48hrs-26-38-screenshot.png
#angus #robot #well #first
#rss #feeds #linksharing #qwibbit

2026-10-26 07:21:48 UTC

Building a Swashplate-less Helicoper Rotor
A helicopter blade uses a swash plate and a set of linkages to change the angle of the blades. Not only does it vary the collective pitch to increase or decrease thrust, but it varies each blade’s pitch throughout each rotation, letting it produce more lift on one side of the rotor. This presented a problem to [worked in theory] — he’s building an RC helicopter from scratch, and this mechanism added both complexity and weight. Instead, he started looking for a way to get around the problem.
There were two options to eliminate the linkages: a linkage-less swashplate design used in Black Hornet drones, and an under-actuated design using angled hinges to control the blade angle. [worked in theory] started with the Black Hornet design, which has the end of each blade run along the swashplate on wheels, while a central spring presses them down. Friction in the hinge and wheels proved too high, and it stopped responding at higher speeds. A second, lower-friction design seemed promising, but it still required actuators, and thus weight, to control the swashplate. [worked in theory] therefore moved on to the under-actuated approach. In this design, the blades are mounted on angled hinges — by varying the motor’s speed throughout each rotation, inertia causes the blades to swing backwards or forwards, changing their pitch.
[worked in theory] tested two such rotor designs: one with one hinge per rotor, and one with one hinge for both rotors. The design using a single hinge seemed less sensitive to friction, was more responsive in testing, and had a more linear control response, so he used that. To actually make the blades, [worked in theory] 3D printed them as flat blanks, then thermoformed them using printed molds. During testing, the blades needed weights added to pull them back toward the standard angle under constant rotation; fortunately, though, this had the side effect of damping out unwanted vibrations.
There’s still a long way to go before the helicopter’s finished, but this is quite an impressive start. This is the second under-actuated propeller we’ve seen recently, both inspired by [Tom Stanton]’s original design.
https://hackaday.com/2026/10/25/building-a-swashplate-less-helicoper-rotor/
https://hackaday.com/wp-content/uploads/2026/10/helicopter_propeller.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/helicopter_propeller.png
#helicoperrotor #blackhornet #building #swashplate #tomstanton
#rss #feeds #linksharing #qwibbit

2026-10-26 03:15:04 UTC

Transforming a Tungsten Ditelluride Monolayer into a Transistor
In the world of silicon semiconductors, the process of creating transistors and similar structures involves various rounds of modifications and additions in order to create the requisite functional layers. A less involved approach would simply create these structures in-situ, with research the past years having focused on transition-metal dichalcogenide (TMDC) monolayers to do exactly this. Recently [Seok Young Min] et al. reported (paywalled, Phys.org summary) on creating transistors in-situ in a tungsten ditelluride (WTe2) monolayer.
By selectively changing parts of the top layer into tungsten oxide (WOx) as an insulator and other sections into n-type WS2 and p-type WSe2 the researchers were able to create functional MOSFETs, without the normally requisite grafting on of different materials. An obvious advantage of this is that this can be done at an atomic scale, potentially achieving densities significantly higher than with industry standard silicon semiconductor technology.
WTe2 is not the only TMDC that could be viable here, of course, with other researchers investigating the use of MoSe2 for a similar purpose, as in this research by [N. Lu] et al. from 2014. This being the creation of 2D semiconductors, referring to the thin layers of these monolayer TMDCs, along with potentially other materials such as graphene.
https://hackaday.com/2026/10/25/transforming-a-tungsten-ditelluride-monolayer-into-a-transistor/
https://hackaday.com/wp-content/uploads/2026/10/tmdc_mosfet_seok_young_min_et_al_science_2026.jpg?w=701
https://hackaday.com/wp-content/uploads/2026/10/tmdc_mosfet_seok_young_min_et_al_science_2026.jpg
#tungstenditelluride #ditelluridemonolayer #transistor #seokyoung #youngmin #tmdc #recently
#rss #feeds #linksharing #qwibbit

2026-10-26 02:15:39 UTC

The Python on Microcontrollers Newsletter: subscribe for free
The Python for Microcontrollers Newsletter is the place for the latest news involving Python on hardware (microcontrollers AND single board computers like Raspberry Pi).
This ad-free, spam-free weekly email is filled with CircuitPython, MicroPython, and Python information that you may have missed, all in one place!
You get a summary of all the software, events, projects, and the latest hardware worldwide once a week, no ads! You can cancel anytime.
It arrives about 11 am Monday (US Eastern time) with all the week’s happenings.
And please tell your friends, colleagues, students, etc.
Please sign up > > >
https://blog.adafruit.com/2026/10/25/the-python-on-microcontrollers-newsletter-subscribe-for-free-10-25/
https://cdn-blog.adafruit.com/uploads/2026/10/cp11.jpg
https://cdn-blog.adafruit.com/uploads/2026/02/Subscribe-2026-02.jpg
https://pbs.twimg.com/media/GlSkmQPWAAMqzKE?format=png&name=small
#microcontrollersnewsletter #python #free #raspberry #please #monday #micropython
#rss #feeds #linksharing #qwibbit

2026-10-25 23:56:27 UTC

Hackaday Links: October 25, 2026
Some disappointing, but perhaps not entirely unsurprising news this week out of Denmark — after announcing last year that they would transition away from Microsoft’s proprietary software, the realities of making it work seem to have caught the government off guard. The word is that a trial program immediately ran into problems when government employees that had been given Collabora tried to collaborate with their peers running Office, and has since been quietly abandoned.
Although there’s probably a joke to be made about different parts of the government not knowing what the other ones are talking about, the reality is that if one group of staffers can’t reliably access the data being produced by another, that’s a pretty big problem. Of course, had they simply asked us nerds, we could have advised them that these sort of issues are inevitable if you don’t fully commit to the effort.
Had the entire government moved to the Open Document Format (ODF) at once they would have avoided the issue, at least when it came to newly created documents, but obviously that’s a considerably larger undertaking than installing Collabora or OpenOffice on a few dozen machines and calling it a day. There’s no word yet on how this stumble will impact Denmark’s larger effort to free themselves of proprietary software, but we’d hazard a guess it’s not a great sign. Hopefully things go better for the Dutch.
Speaking of users trying to improve their personal software situation, The Verge has an interesting article on a recent trend of frustrated users pointing AI tools like Claude at their smart TVs, with a few success stories posted to social media showing off interfaces that have been stripped of ads or replaced with something else entirely. It’s compelling stuff for anyone who’s unhappy with their current smart TV experience, but the whole thing isn’t quite as technically impressive as it might seem on the surface.
As the TV’s in question are running Android, all the AI tools need to do is connect to them over Android Debug Bridge (ADB) and uninstall any offending packages that might be providing ads, and similarly creating a customized launcher interface is a matter of spinning up an Android app and installing it over the network. The results may look like arcane magic to the uninitiated, so we appreciate The Verge pointing out that it’s all pretty basic stuff for anyone familiar with Android development.
On the subject of extracting unwanted components, a delicate operation to remove the masts of the sunken WWII cargo ship SS Richard Montgomery was completed successfully earlier this week off the coast of Sheerness, England. To those unfamiliar with this particular vessel that might not sound like a big deal, but when you’re dealing with a wreck holding an estimated 1,400 metric tons of explosives that have been deteriorating since 1944, even approaching the area needs careful planning and coordination.
Masts of the SS Richard Montgomery in 2014. Image Credit: Christine Matthews
There was a concern that the masts and their supporting structures were on the verge of collapsing into the hull of the wreck, which experts warned could potentially trigger an explosion large enough to endanger life and property. Actually removing the explosives from the ship itself will be a far larger undertaking, but at least for the time being, removing the masts has helped stabilize the situation.
Finally, if you’re looking to learn about something a little more local than a potentially explosive situation in Sheerness (apologies to anyone in Sheerness), check out Local Wikipedia. Created by [Ed Jefferson], the site lets you filter Wikipedia pages by their distance from your location or whatever other landmark you wish. By default it shows results that are within 1.5 miles, but if you don’t have anything too exciting within range it will start opening up the radius to pull in more results.
See something interesting that you think would be a good fit for our weekly Links column? Drop us a line, we’d love to hear about it.
https://hackaday.com/2026/10/25/hackaday-links-october-25-2026/
https://hackaday.com/wp-content/uploads/2014/11/had-links-banner.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/links_102526_vibetv.png?w=542
https://hackaday.com/wp-content/uploads/2026/10/links_102526_masts.jpg
#collabora #denmark #androiddebug #verge #documentformat #opendocument #debugbridge
#rss #feeds #linksharing #qwibbit

2026-10-25 21:04:42 UTC

A 3D Printed Marble Clock, but it’s Scrolling Text
With the topic of marble clocks having been quite well explored at this point, it raises the question of how easy it would be to take the basic principle and create a text display using black and white marbles. As [Ivan Miranda] found out in a recent marble text scroller project, this is far from easy.
The reason why a scrolling text display was picked comes down to not wanting to be limited to a fixed number of digits. This resulted in a round wheel design, with inner steel ball bearings and a stepper motor on both the wheel and an inner selector mechanism. These respectively align the marble channels and pick the right color of marbles to be dropped into any of the wheel’s slots, creating the right sequence of marbles for the target text.
Perhaps the most amazing thing about it is that it’s an absolutely massive structure, yet it’s all 3D printed and bolted together. It took a number of trial-and-error cycles, and debugging issues like the IR sensors getting confused by daylight, but it now mostly seems to work all right.
There are still some remaining issues, such as having to manually home the wheel before starting, and the ratio of black vs white marbles can cause unexpected gaps in the final text. Despite this the text is quite legible and definitely infinite.
https://hackaday.com/2026/10/25/a-3d-printed-marble-clock-but-its-scrolling-text/
https://hackaday.com/wp-content/uploads/2026/10/scrolling_marble_text_ivan_miranda_youtube.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/scrolling_marble_text_ivan_miranda_youtube.jpg
#scrollingtext #printedmarble #marbleclock #ivanmiranda
#rss #feeds #linksharing #qwibbit

2026-10-25 20:32:23 UTC

ESP-NOW Walkie Talkies
Ditch the smart phone and communicate with your buddy by building this set of walkie talkies! A Feather ESP32-S3 Reverse TFT runs Arduino code that uses the ESP-NOW wireless protocol to send and receive I2S audio packets, up to 10 seconds each. The w.FL antenna adds extra range to communicate at longer distances indoors or outdoors.
Make your own following the guide.
https://blog.adafruit.com/2026/10/25/esp-now-walkie-talkies/
https://cdn-blog.adafruit.com/uploads/2026/10/arduino_compatibles_edited_P1490595-600x450.jpg
#walkietalkies #reversetft #feather #make
#rss #feeds #linksharing #qwibbit

2026-10-25 18:54:03 UTC

Local Wikipedia
A Mr. Rogers might sing.. these are the places in your neighborhood.. Get better acquainted with your neighborhood with Local Wikipedia, enter your location and Local Wiki will highlight wiki entries within a half hour walk.
Local Wikipedia is Wikipedia, but only for things a half hour walk from you.
Local content is direct from Wikipedia – geocoded pages only.
If there are fewer than 25 things close to you, it takes the closest 25 things within about 6 miles. If there are more than 500 things only the closest 500 will be included.
Your location stays in this browser: links you share don’t include it.
Check it out!
https://blog.adafruit.com/2026/10/25/local-wikipedia/
https://s.w.org/images/core/emoji/17.0.2/72x72/1f3b6.png
https://s.w.org/images/core/emoji/17.0.2/72x72/1f3b5.png
https://cdn-blog.adafruit.com/uploads/2026/10/Screenshot-2026-10-23-at-1.44.01-PM.png
#localwikipedia #get
#rss #feeds #linksharing #qwibbit

2026-10-25 18:17:37 UTC

Mesh Network Telephony Over Bluetooth on Android Phones
Telephony is a bit of a mixed bag. On the one hand, being able to talk to people in far off places is kind of neat, at least in theory. On the other hand, you’re usually reliant on a centralized network, which isn’t ideal to the mindset of most hackers.[Gautam]’s MeshLive project deals with that last one, offering a decentralized mesh network solution based on Bluetooth for Android phones that can handle both voice and video.
Rather than relying on dedicated hardware, this particular mesh piggybacks on your phone, and exists only as an Android application. Calls are end-to-end encrypted for both voice and video — though two-way video calling is still experimental. More testing has gone into video broadcasting, where a stream goes out one-way. The capability is available for voice, as well.
Each user has a unique identifier that can be scanned to create contacts, but it isn’t otherwise clearly identifiable to everybody. You’ll only appear with a random name that changes every 15 minutes to other users in range who aren’t your contacts. Range is of course the Achilles heel of this project, since it’s using the Bluetooth hardware of ordinary smartphones. It’s possible to extend the range of Bluetooth significantly with the right hardware, but we imagine most folks aren’t carrying directional antennas around with them. While every phone does forward the signal to as many others as it can, it can only do so for about 20 meters.
Of course LoRa remains the protocol of choice for mesh networking, though it’s normally used for text messages only. We have seen voice packets over LoRa, but anything LoRa requires dedicated hardware while this only requires an app.
https://hackaday.com/2026/10/25/mesh-network-telephony-over-bluetooth-on-android-phones/
https://hackaday.com/wp-content/uploads/2026/10/MeshLive-screenshot.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/MeshLive-screenshot.png
#androidphones #meshnetwork #bluetooth #range #lora #gautam
#rss #feeds #linksharing #qwibbit

2026-10-25 17:44:00 UTC

Eye of Sauron: long-range hidden spy camera detection and positioning with inbuilt memory EM radiation
Researchers from Hunan University, UC San Diego, and Michigan State University presented ESauron at USENIX Security ’24, a system that finds hidden spy cameras by listening for the electromagnetic radiation their memory gives off.
The idea rests on something every camera has to do. Raw images get encoded and compressed before they are sent anywhere or written to storage. That work happens in read-write memory, and the memory clock drives switching voltage regulator activity that varies with the workload. The result is EM radiation at the clock frequency.
When the scene in front of a camera changes, the encoder suddenly has more to do, and the EM signature jumps. ESauron triggers that on purpose by causing a scene change, then watches for the surge. Because it reads radiation and not network traffic, it works on wireless, wired, and offline cameras that record to a card.
Tested against 50 camera products, the prototype detected every one with 100% accuracy after four stimuli. Detection range passed 20 meters, including through obstructions, and the system located each camera.
See the video below and more on usenix.org.
https://blog.adafruit.com/2026/10/25/eye-of-sauron-long-range-hidden-spy-camera-detection-and-positioning-with-inbuilt-memory-em-radiation/
https://cdn-blog.adafruit.com/uploads/2026/10/a1-16.png
#rss #feeds #linksharing #qwibbit

2026-10-25 16:33:34 UTC

Adafruit Weekly Editorial Round-Up: CircuitPython 11.0.0-alpha.2, Halloween Gift Guide Sale, & more
ADAFRUIT WEEKLY EDITORIAL ROUND-UP
We’ve got so much happening here at Adafruit that it’s not always easy to keep up! Don’t fret, we’ve got you covered. Each week we’ll be posting a handy round-up of what we’ve been up to, ranging from learn guides to blog articles, videos, and more.
CircuitPython 11.0.0-alpha.2 Released!
CircuitPython Text to Speech
Coraline flexi keychain
Halloween Gift Guide Sale
Catch up with us on our blog, in our learn system, or on YouTube.
https://blog.adafruit.com/2026/10/25/adafruit-weekly-editorial-round-up-circuitpython-11-0-0-alpha-2-halloween-gift-guide-sale-more/
https://cdn-blog.adafruit.com/uploads/2019/01/IINewImage-21-1-1.png
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_circuitpython_11_poster_sm-768x1024-1.jpeg
https://cdn-blog.adafruit.com/uploads/2026/10/circuitpython_hgero-600x227.jpg
#halloweengift #weeklyeditorial #giftguide #guidesale #adafruitweekly #salecatch #circuitpython #speechcoraline #released #text
#rss #feeds #linksharing #qwibbit

2026-10-25 15:26:33 UTC

Simple, Reliable RF Remote Control
Some of the first remote controls available to consumers used sound, visible light, or even just wires to communicate with their parent device. It was many years between these first rudimentary remotes before they standardized around infrared or RF signaling. Even then it was a while before remote controls were reliable enough to not have to think about anymore. They’ve gotten so good now that there are small modules available that let us quickly build these devices to perform all manner of tasks.
[Igor Brichkov] is demonstrating this project because his garage door remote control suddenly stopped working. The RF receiver and transmitter circuits are readily available and inexpensive, but they need some support circuitry to work properly. The transmitter is paired with an encoder which is provided a binary code by wiring various pins to power and ground. This “code” is sent to the receiver which has a decoder and listens for that specific code. When the codes match it changes the state of one of its pins, which is used in this case to short the garage door’s remote terminals and signal it to open the door.
Although the resulting handheld remote with its single button looks a bit like something from 1950s science-fiction, it’s an effective solution. Especially when compared to possibly trying to reprogram a proprietary remote, find one from a company that doesn’t exist anymore, or rebuild one that operates on a bizarre frequency. With access to the physical hardware, it turns out a lot of things are controlled by just shorting pins together, and anything can do that from wires to RF transmitters.
https://hackaday.com/2026/10/25/simple-reliable-rf-remote-control/
https://hackaday.com/wp-content/uploads/2026/10/rf-remote-main.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/rf-remote-main.png
#remotecontrol #reliable #igorbrichkov #even
#rss #feeds #linksharing #qwibbit

2026-10-25 14:52:45 UTC

Building Passive Headphones
YouTuber Paul Lagier designed and built 3D printed passive headphones to enable easy repairs if anything breaks.
The design combines 3D-printed ear cups, TPU seals, an adjustable headband and interchangeable side panels. In this video, I’ll show you how I designed the parts in Shapr3D, put together the electronics and turned everything into a working pair of headphones and find out how they actually sound.
See more
Learn how to customize your headphones with 3D printed accessories or NeoPixels in the Adafruit Learning System!
https://blog.adafruit.com/2026/10/25/building-passive-headphones/
https://cdn-blog.adafruit.com/uploads/2016/03/NewImage-304.png
#passiveheadphones #paullagier #learningsystem #youtuberpaul #adafruitlearning #tpu
#rss #feeds #linksharing #qwibbit

2026-10-25 12:34:32 UTC

Meshtastic Pet Tracking
Most commercial pet trackers require a subscription or network connection to function. [Jon G Aguado] wanted a better way and designed LIA, a Meshtastic collar tracker.
LIA uses a custom PCB containing a ESP32-S3, LoRa radio, GPS/GNSS receiver, and a charge controller for the 18650 or 5023450 pouch Li-ion cell powering the device. Everything fits inside a 3D printed enclosure, and the device is charged via a magnetic 4-pin USB pogo connector to increase weather resistance.
One of the neat features of this particular tracker is that [Aguado] gave it two different power modes. High power gets a location fix every 30 seconds and has a pair of bright LEDs for visual assistance, low power only gets a fix every minute or so, and it can also be set to off, which is something we wish more device manufacturers remembered should be an option.
We hope anyone planning on using Meshtastic and LoRa in the US is aware of the issues surrounding FCC compliance, and if you want to track your pet another way, maybe KineFox is an option?
https://hackaday.com/2026/10/25/meshtastic-pet-tracking/
https://hackaday.com/wp-content/uploads/2026/10/LIA-Open-Source-Meshtastic-LoRa-Pet-Tracker.webp?w=800
https://hackaday.com/wp-content/uploads/2026/10/LIA-Open-Source-Meshtastic-LoRa-Pet-Tracker.webp
#pet #aguado #lia #lora #jon #gps #gnss #usb #pcb
#rss #feeds #linksharing #qwibbit

2026-10-25 08:37:50 UTC

An Analog TV Station For Anyone
If you’re a collector of older TVs, you’re probably facing the problem in some form of having no transmissions to tune in to. With many sets you can use a SCART or other A/V input, but nothing beats using the thing as it was intended. [BorisDigital] had exactly this problem, and since he worked in a TV transmitter control room in the 1990s, he’s made a small TV station that looks and operates like the real thing.
It’s a 10 inch rack stuffed with goodies, each of which replicates the function of a piece of broadcast gear which would have cost a small fortune back in the day. At the top is a transmitter, a relatively inexpensive board from China. Below it a clock and audio monitor powered by a Pi Pico, then a vectorscope, waveform monitor, and monitor powered by a set of Pi 5s with USB video digitisers, a pair of SD card video record/play units — yet more Raspberry Pi — and at the bottom, an automatic scheduler powered by another fruity board from Cambridge. If you’re not into TV the construction may be worth a second look. Those neat looking rack front panels are 3D printed with different filaments for the lettering, and are both robust and stylish. We can already see how this could be used in our work.
We miss analogue TV, partly because it was a wonderfully intricate technology that, beautifully, just worked. it’s a few years now since we reported on the last gasp of analogue TV in the USA, about a decade after it was turned off where this is being written.
https://hackaday.com/2026/10/25/an-analog-tv-station-for-anyone/
https://hackaday.com/wp-content/uploads/2026/10/tv-station-featured.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/tv-station-featured.jpg
#scart #tv
#rss #feeds #linksharing #qwibbit

2026-10-25 06:57:21 UTC

Remembering the Weirdest Nintendo DSi Accessory
The Nintendo DSi was released in November 2008, and boasted a new feature not formerly seen on the brand’s handhelds—it had two cameras, inside and outside. It let the console take photos, a feature rather fitting given it was an era in which phone cameras had become the norm. Only, it wasn’t so good out of the box. However, [gavff] recently found an accessory from way back when that aimed to make the DSi’s camera somewhat more capable.
For some reason, the console accessories company Nyko decided that that the Nintendo DSi deserved an 8x optical zoom lens. Never mind that the console’s cameras were limited to a resolution of just 640 x 480 pixels, it was deemed important that the handheld have the ability to capture images of things that were somewhat farther away. The lens mounted to a specially-designed case that fit around the original DSi’s shell. It’s not particularly clear what the intended use case was, but if you wanted to expand the capability of your DSi camera, this was one way to do it. You could get some pretty sharp photos if you knew what you were doing, as [gavff] demonstrates in the video.
The video then takes things farther, putting an even larger, sillier telescopic camera lens on the DSi. [gavff] used it to capture a photo of the Moon, with the benefit that unlike modern smartphones, there’s no AI faking the results. The video also touches on the goofy Mad Catz flash accessory that used the DSi’s charge port.
We love seeing silly lenses on cameras that were never supposed to host them. Also, isn’t it wonderful that our ancient “Nintendo DS Hacks” category is getting some love again after all this time? We’ve actually published a bunch of DS hacks this year.
https://hackaday.com/2026/10/24/remembering-the-weirdest-nintendo-dsi-accessory/
https://hackaday.com/wp-content/uploads/2026/10/What-if-the-DSi-Camera-was-good_-0-1-screenshot-1.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/What-if-the-DSi-Camera-was-good_-0-1-screenshot-1.png
#nintendodsi #hacks #madcatz #november
#rss #feeds #linksharing #qwibbit

2026-10-25 05:49:37 UTC

Pushing Bluetooth out to 12 Kilometers
Bluetooth is a short-range protocol that’s great for peripherals and finding your keys, but it’s limited range is mainly a product of how it’s usually implemented. A recent video from [nktbuilds] demonstrates this by extending its range out to 12 kilometers, or around 7.5 miles.
The secret is twofold: one is the antenna, a parabolic unit that captures far more than the dinky dipole in your phone. The other is a very sensitive receiver with a much lower noise floor. What you won’t see here is any extra power than you get stock out of one of those generic coin-sized Bluetooth tracker tags. It’s kind of obvious, in retrospect: grab more signal, lower your noise floor, and get a better result. Still, it certainly wasn’t obvious it would work out to 1200 m, and it’s an impressive feat by [nktbuilds]. We’re going to have to keep it in mind next time we lose our keys.
Of course this doesn’t mean you should jump to Bluetooth for distance communications. You’re still better off sticking with something like LoRA for that, especially since it’s good to hundreds of miles if you can get line-of-sight — or even tens of thousands with the right setup.
https://hackaday.com/2026/10/24/pushing-bluetooth-out-to-12-kilometers/
https://hackaday.com/wp-content/uploads/2026/10/long-range-bluetooth-feat.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/long-range-bluetooth-feat.jpg
#pushingbluetooth #kilometers #still
#rss #feeds #linksharing #qwibbit

2026-10-25 01:14:40 UTC

The Slurptop is Both Drool Worthy and Practical
There are two kinds of cyberdeck: the kind someone makes on a lark and operates purely on ‘rule of cool’, and the kind designed to do practical work. The Slurptop by [Slurpburgers] is decidedly in the second category — but that doesn’t mean it lacks for coolness. What’s cooler than a power-tool battery?
Don’t you just want to slurp that up?
That last feature might make this closer to the Neuromancer definition of cyberdeck than most featured on these pages. You still can’t jack it into your cortex, but it does have the ‘assemble from off the shelf components at need’ vibe of the original concept. It also means there should be plenty of battery power to keep working with the power-hungry x86-based GMKtec MiniPC that runs this thing.
If the battery gets low, which it will after about 4 hours or so, swapping is easy — but not hot swapping. Luckily [Slurpburgers] grabbed a module meant for Uninterruptible Power Supplies to swap over to wall current, so this device can be plugged in whenever necessary. Alas, charging must be done on the factory charger, not the device, but that swapping really adds to the ‘future of the past’ cyberpunk flare of the device in our opinion.
Speaking of the past, why did we ever stop putting mechanical keyboards and trackballs onto laptops? The inputs on this thing are glorious, and this writer’s hands envy the ergonomic curve of it while typing away on an old HP Pavilion’s sad and squishy low-profile keys. The trackball itself is a minor hack, being made using the guts of an old gaming mouse. Not everyone will approve of every design choice here, but that’s the point of doing it yourself — so like [Slurpburger], you can have it your way.
This is hardly the first time we’ve seen a clacky laptop but we can’t recall a cyberdeck made with tool batteries before.
Thanks to [JohnU] for the tip!
https://hackaday.com/2026/10/24/the-slurptop-is-both-drool-worthy-and-practical/
https://hackaday.com/wp-content/uploads/2026/10/slruptop-feat.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/slurptop-thumb.jpg?w=250
https://hackaday.com/wp-content/uploads/2026/10/slruptop-feat.jpg
#bothdrool #droolworthy #slurptop #practical #slurpburgers #power #powersupplies #uninterruptiblepower
#rss #feeds #linksharing #qwibbit

2026-10-24 23:22:18 UTC

Reverse engineering a commercial spatial audio effect
Austin Shijo wanted a Linux version of a Windows audio effect that pushed music out of the head and made it feel less pressed against the ears. Writing on epestr.com, he describes first trying to rebuild the effect by hand with PipeWire, HRTF databases and an LLM as a sounding board. The MIT KEMAR set was recorded in an anechoic chamber and sounded wrong to him. SADIE II, which includes room responses, came closer, but the project stalled.
The second attempt skipped the algorithm entirely and measured the filter instead. He only had access to the program on a friend’s laptop, so he built a single test file, played it through the effect once and recorded the output.
The file packed in impulses at three amplitudes across both channels, a logarithmic sine sweep, steady tones, a multitone, repeated sections and a noise segment, plus clicks at the start for alignment. The checks confirmed the main surround mode was linear and time invariant, so four impulse responses captured it. Two other modes changed gain over time and could not be reproduced with a fixed convolution.
See more at epestr.com and content on GitHub.
https://blog.adafruit.com/2026/10/24/reverse-engineering-a-commercial-spatial-audio-effect/
https://cdn-blog.adafruit.com/uploads/2026/10/aaa-19.png
#audioeffect #austinshijo #linux #hrtf #llm #mit #sadie
#rss #feeds #linksharing #qwibbit

2026-10-24 22:14:55 UTC

2026 Retrocomputing Challenge: I Would Do Anything For Serial Data
These days we take high-speed networking for granted, but it can be difficult to get vintage computers talking to modern machines. To help solve this problem [jaime] came up with Meatloaf which can provide files to a Commodore regardless of their location or medium of storage.
Meatloaf is an ESP32 device at its core, which plugs in to any of several Commodore computers through their IEC serial port. Many similar systems exist to bridge the gap between the modern world and the now-retro one, but this one connects to a dedicated service which points towards files no matter where they’re stored. There is some local storage, but it can also retrieve files from any active URL, and Meatloaf retrieves the files and then sends them to the Commodore over that serial link.
Part of what makes this unique is that the user doesn’t need to configure Meatloaf in any particular way, everything is done from the Commodore as long as the URL is known to the user. The system can even parse nested files like archive file types and send them along to the computer just like it would if they were on a period-correct floppy drive. There’s a GitHub project page as well for anyone looking to get into the weeds of this serial data interface.
https://hackaday.com/2026/10/24/2026-retrocomputing-challenge-i-would-do-anything-for-serial-data/
https://hackaday.com/wp-content/uploads/2026/10/meatloaf_feat.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/08/RetroComputing_728x90.jpg
https://hackaday.com/wp-content/uploads/2026/10/meatloaf_feat.jpg
#serialdata #commodore #meatloaf
#rss #feeds #linksharing #qwibbit

2026-10-24 21:42:53 UTC

Observe El Niño with NASA
This visualization compares three ocean data products, sea surface temperature anomaly, apparent visible wavelength, and sea surface height anomaly, over the same months in 2025 and 2026. Signals of El Niño in each map are highlighted with pop-up labels. Credits: NASA’s Scientific Visualization Studio via NASA
Keep tabs on El Niño with NASA’s satellites.
A phenomenon rarer than a solar eclipse and more powerful than any single storm system is unfolding this fall, and NASA is tracking it closely.
El Niño is a natural climate pattern that emerges roughly every two to seven years marked by warmer-than-normal water temperatures in parts of the equatorial Pacific. NASA scientists are keeping watch as it flips trade winds, redistributes ocean heat, scrambles rain patterns, and raises sea surface height across parts of the Pacific./blockquote>
https://blog.adafruit.com/2026/10/24/observe-el-nino-with-nasa/
https://cdn-blog.adafruit.com/uploads/2026/10/Screenshot-2026-10-19-at-6.33.40-PM-600x222.png
#nasa #scientificvisualization #visualizationstudio #credits #signals
#rss #feeds #linksharing #qwibbit

2026-10-24 20:02:52 UTC

Sound Reactive Paper Lanterns with LedFx
Make a strand of sound reactive paper lanterns and hang them in your space. Control them with a Feather ESP32 running WLED software. Add sound reactive animations using the sound on your computer over WiFi using the free, open source LEDFx software. This software makes it easy to add customizable sound reactivity to your lights.
Check out the full guide!
https://blog.adafruit.com/2026/10/24/sound-reactive-paper-lanterns-with-ledfx-2/
https://cdn-blog.adafruit.com/uploads/2026/10/led_pixels_spheres_colorful-300x225.jpeg
#paperlanterns #reactivepaper #soundreactive #ledfx #feather #add #wled #check
#rss #feeds #linksharing #qwibbit

2026-10-24 18:54:06 UTC

That Weird 7-Pin S-Video Port on Old Laptops
Even though laptops from around the early 2000s came with just about every conceivable port on them, they still would often feature a somewhat unusual combined video output port. While at its core this was just a 4-pin analog S-video output, the three additional pins on the mini-DIN connector provided some more features. Of course, as [VWestlife] found out during his archaeological research, not every manufacturer used the same pinout here.
The naming for this specific port differs, with the name ‘S-video+’ appearing regularly, yet many descriptions glossing over the additional pins and only mentioning that it can be used with a 4-pin S-video connector. As it turns out, most manufacturers used roughly the same pinout, matching the shown Dell one. This adds composite output, along with two S/PDIF digital audio pins that could be routed out with an adapter into their full-sized ports.
Of course, the Apple PowerBook G4 had to be that exception again, with it omitting the audio pins and putting the composite signal on pin 5. This left the last two pins completely unused, but serving to completely confuse anyone who thought that they could get more out of the port with an adapter for those uncouth PC systems.
As to the remark at the end about how the transition to ‘just USB ports’ has made everything better, we’d challenge the average person to look at a random USB-C port and tell based on its appearance which standards it actually supports.
https://hackaday.com/2026/10/24/that-weird-7-pin-s-video-port-on-old-laptops/
https://hackaday.com/wp-content/uploads/2026/10/7-pin_s-video-connector_laptops_vwestlife_youtube.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/7-pin_s-video-connector_pinout_vwestlife_youtube.jpg?w=400
https://hackaday.com/wp-content/uploads/2026/10/7-pin_s-video-connector_laptops_vwestlife_youtube.jpg
#port #laptops
#rss #feeds #linksharing #qwibbit

2026-10-24 18:22:12 UTC

ESP32-Powered Talking Smoke Pumpkin #ElectronicHalloween
This is a paper papier-mâché jack-o-lantern that emanates smoke and lights up with the help of an ESP32. Once trick-or-treaters are near an ultra sonic sensor triggers a terrifying sequence including a very creepy voice recording. Shared by DBMaking on Instructables.
The protagonist is this creepy talking pumpkin that spits fog and speaks with a monstrous voice. I made it using papier-mâché, combined with anESP32, a DFPlayer Mini, an ultrasonic sensor, LEDs, and of course… a smoke machine!
See the full guide!
HAPPY HALLOWEEN! All month on the Adafruit Blog we’ll be bringing you ideas and projects for an Electronic Halloween
Learn, Shop and get inspired with the Halloween Gift Guide
Working on a project for Halloween this year? Let us know about it or tag us on socials!
https://blog.adafruit.com/2026/10/24/esp32-powered-talking-smoke-pumpkin-electronichalloween/
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_halloween_sale_2026_1300x437-1.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/FUDMISMM9CSSD0U.webp
https://cdn-blog.adafruit.com/uploads/2024/10/small-halloween-foot-1-300x176.png
#rss #feeds #linksharing #qwibbit

2026-10-24 16:41:42 UTC

The Hidden Speakers of Cirque du Soleil’s “O”
Matt Obernesser, head of audio for Cirque du Soleil’s O, takes Dallas Taylor on a sound tour. This one’s for the audio folks!
https://blog.adafruit.com/2026/10/24/the-hidden-speakers-of-cirque-du-soleils-o/
#hiddenspeakers #soleil #cirque #dallastaylor #mattobernesser
#rss #feeds #linksharing #qwibbit

2026-10-24 15:31:05 UTC

Making for Others
One of the nicest things about the Hackaday community, and the open-source hardware community at large, is the incredible generosity of one hacker to another. But it’s not purely altruism – it’s also just a great feeling to be able to share your work with other folks who understand what it represents and how to use it.
I’m looking at my workbench right now. Because I’ve been testing out the Supercon badge prototype, there is a small pile of SAOs to the right. SAOs are the perfect size for giving out to fellow hackers, because they can be small, inexpensive, and yet still embody a ton of your creativity. [Tom]’s marvelous Ode to the SAO, even opens with this as one of the main benefits, alongside teaching you “full-stack” PCB production at small scale; they are cheap enough that you can give them away. Of course, you end up getting as many or more than you give, so it’s not just the pure joy of giving at work in the SAO scene.
On my left, I have a couple dev boards made by fellow hackers. One is a clone of the Raspberry Pi Pico that’s made by the high-school students of Hack Club, and the other is [CNLohr]’s ch32v003fun board and esp32s2-funprog programmer. I needed to test out a quick microcontroller application, and having a few dev boards on hand is always useful. Because I know the people who made these boards, I tend to reach for these over their commercial alternatives. Romantic? Maybe. But they were given to me by friends.
And of course the badge prototype is sitting in the middle of all this, and that’s how I really know about the joy of giving away your designs to fellow hackers. We at Hackaday are in the incredibly fortunate position of being able to dream up a new and fun badge every year, and give it out to hundreds of fellow hackers. Heck, this year, we’re making 1,000. I say “fortunate” because we don’t have to pay for them ourselves, but rather our Supercon sponsors help pick up the bill, and that means we can make stuff that’s far cooler than our budgets would otherwise allow.
So to everyone in the SAO scene, may you give away your designs to people who really appreciate them. For the folks who have built tools for other hackers to use, you should know that the recipients probably reach for your boards over their bland commercial alternatives. And for all of you coming to Supercon in two weeks, we hope you dig the badge. It has maybe become a bit of a cliché these days, but you should know that it’s made with love.
This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on the web version of the newsletter.
Want this type of article to hit your inbox every Friday morning? You should sign up!
https://hackaday.com/2026/10/24/making-for-others/
https://hackaday.com/wp-content/uploads/2023/08/Collaboration01_featured.png?w=800
https://hackaday.com/wp-content/uploads/2024/08/08-delorean-sao_thumbnail.png?w=400
https://hackaday.com/wp-content/uploads/2023/08/Collaboration01_featured.png
#sao #because #supercon #hackaday
#rss #feeds #linksharing #qwibbit

2026-10-24 14:59:10 UTC

GitHub – ankur608/ArduinoUnoQ_AdafruitTouch
Developer ankur608 has published an open source Arduino library on GitHub for using the Adafruit 2.8″ TFT Touch Shield v2 with Capacitive Touch (PID 1947) on the Arduino UNO Q, which runs an STM32U585 core.
The shield carries its SPI lines on the 6-pin ICSP header rather than pins 11 through 13. On the UNO Q, those map to MOSI 23, MISO 22 and SCK 24. The library handles that remapping, sets up the FT6206 capacitive touch controller over I2C, and does the coordinate math.
The FT6206 digitizer reports touches in portrait orientation at 240 x 320. The library’s screen.getPoint() function applies the transformation for whichever rotation you pick, so touch coordinates line up with what is on screen. Installation is a clone into your Arduino libraries directory or an install from the Git URL, plus the core Adafruit driver dependencies.
Examples appear in the Arduino IDE under File, Examples, ArduinoUnoQ_AdafruitTouch. One of them renders Yusuke Murata manga artwork as 1-bit Floyd-Steinberg dithered 240 x 320 panels. The project is MIT licensed.
See more on GitHub.
https://blog.adafruit.com/2026/10/24/github-ankur608-arduinounoq_adafruittouch/
https://cdn-blog.adafruit.com/uploads/2026/10/picture-90.jpg
#capacitivetouch #github #tfttouch #uno #arduinoide #shield #giturl #examples #yusukemurata #pid
#rss #feeds #linksharing #qwibbit

2026-10-24 12:01:27 UTC

AlgoLaser DIY KIT MK3 Review
Acmer's SM MOPA laser comes with great power, but leaves responsibility to the user.
The post AlgoLaser DIY KIT MK3 Review appeared first on Make: DIY Projects and Ideas for Makers.
https://makezine.com/article/digital-fabrication/algolaser-diy-kit-mk3-review/
https://i0.wp.com/makezine.com/wp-content/uploads/2026/10/3.DIYKITMK3_-4.webp?fit=750%2C750&ssl=1
#kit #mopa
#rss #feeds #linksharing #qwibbit

2026-10-24 11:29:21 UTC

Watch VCF Southwest in Retrotastic SGI-Edited Footage
There’s just something about backing way, way off the cutting edge to rediscover the simpler joys of yesteryear. We’ve got a contest about to wrap up along those lines, and there are festivals celebrating all things retro in the world of computers and electronics the world over. Vintage Computer Festival (VCF) Southwest happened back in the summer, but [Wave Design] just posted a gloriously retro retrospective, complete with the full 1990s video-editing workflow, completed on an SGI O2.
The footage was recorded on a 1990s vintage DV camera, and read using a somewhat-newer Sony tapedeck that we sadly have to admit also counts as retro in these late days. That gets piped into a vintage SGI O2 workstation that would have had us drooling back in the day, whose only concession to modernity is the inclusion of an NVMe SSD through a collection of adapters we can only call a hack. This may be burying the lede deep, but it turns out there is now an NVMe driver for IRIX 6.5. Using a modern SSD saves [Wave] from dealing with the literal stack of external drives video editing called for back in the day, so we can’t hardly blame him.
After the hardware walk-through, [Wave]’s video gets into the software, which is surprisingly modern. The footage he creates is decidedly not. It looks exactly like it was broadcast in 1996, perhaps following an episode of ReBoot — which conveniently enough, also used SGI workstations in its production, though with a decidedly rarer type of digital video tape.
https://hackaday.com/2026/10/24/watch-vcf-southwest-in-retrotastic-sgi-edited-footage/
https://hackaday.com/wp-content/uploads/2026/10/VCF-on-SGI-e1792773738412.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/VCF-on-SGI-e1792773738412.jpg
#vcf #footage #wave #sgi #wavedesign #computerfestival #vintage #ssd #nvmessd #using
#rss #feeds #linksharing #qwibbit

2026-10-24 10:55:09 UTC

The Python on Microcontrollers Newsletter: subscribe for free
The Python for Microcontrollers Newsletter is the place for the latest news involving Python on hardware (microcontrollers AND single board computers like Raspberry Pi).
This ad-free, spam-free weekly email is filled with CircuitPython, MicroPython, and Python information that you may have missed, all in one place!
You get a summary of all the software, events, projects, and the latest hardware worldwide once a week, no ads! You can cancel anytime.
It arrives about 11 am Monday (US Eastern time) with all the week’s happenings.
And please tell your friends, colleagues, students, etc.
Please sign up > > >
https://blog.adafruit.com/2026/10/24/the-python-on-microcontrollers-newsletter-subscribe-for-free-10-24-2/
https://cdn-blog.adafruit.com/uploads/2026/10/cp11.jpg
https://cdn-blog.adafruit.com/uploads/2026/02/Subscribe-2026-02.jpg
https://pbs.twimg.com/media/GlSkmQPWAAMqzKE?format=png&name=small
#microcontrollersnewsletter #python #free #raspberry #please #monday #micropython
#rss #feeds #linksharing #qwibbit

2026-10-24 09:47:53 UTC

A Walkie Talkie Interface For Claude
[Bookmari] had a problem — working as a delivery driver, they wanted to work on various projects with Claude Code while out and about. Unfortunately, it simply wasn’t practical to write prompts and read answers on the job. Thus, they whipped up Walkie Claudie, so they could use their voice instead.
The concept is simple enough, it’s an interface that lets you talk to Claude using speech recognition, and lets Claude talk back to you with a text-to-speech engine. It runs on a smartphone, with a direct network connection to the PC running Claude, though you can use a VPN if you’re distantly located. [Bookmari] has a push-to-talk setup so that pushing a button on their Bluetooth earbuds lets them talk directly to Claude. There’s also a special mode to keep the channel active during long pauses if you need a while to collect thoughts and vocalize them. Just for fun, the interface is styled like an old-school walkie LCD, and there’s fun little details like synthesized squelch and channel-switch noises and so on.
If you’re looking for a way to stay hooked up to your AI assistant at all times, this could prove useful to you. Alternatively, consider if maybe it’s worth taking a break sometimes, or check out other Claude Code projects we’ve seen of late.
https://hackaday.com/2026/10/24/a-walkie-talkie-interface-for-claude/
https://hackaday.com/wp-content/uploads/2026/10/en-main_94b4d2-e1792559432120.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/en-main_94b4d2-e1792559432120.png
#claude #bookmari #code #vpn #lcd
#rss #feeds #linksharing #qwibbit

2026-10-24 06:50:52 UTC

Using an Unmodded GBA as a Music Synth
The style and sound of older video games is unique enough that they’re still copied in relatively modern games like Undertale, Celeste, or Shovel Knight. There’s also a vibrant chiptune community making music on the older hardware directly. Often this involves hardware modding or otherwise finding chips from older gaming systems to replicate that unique retro gaming sound authentically. But disassembling older systems is not always necessary. Take a look at this Game Boy Advance synthesizer which uses the GBA hardware with no modifications at all.
The key to making this work is the GBA’s multiboot feature, which allowed these systems to send executable code over a link cable to other consoles which didn’t have cartridges. This meant that friends could play multiplayer games without each one needing their own cartridge, but it also means that nowadays people can send their own custom software directly to the console’s RAM without much extra effort. To run the synthesizer software, the GBA is connected to a computer, the software is started, and then when the GBA is powered on the snythesizer is automatically loaded into its RAM. The audio output is played over the headphone jack, and various controls are available on the computer and on the console.
In the video linked below, [Andy] is using the GBA with some other musical hardware and the sounds he’s getting from the unmodified console are impressive. It could certainly be a go-to for anyone interested in getting started in this style of music or who doesn’t want to do something like take apart an original Sega Genesis for the audio circuitry.
https://hackaday.com/2026/10/23/using-an-unmodded-gba-as-a-music-synth/
https://hackaday.com/wp-content/uploads/2026/10/gba-chiptune-main.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/gba-chiptune-main.png
#rss #feeds #linksharing #qwibbit

2026-10-24 06:18:26 UTC

Happy Mole Day 2026! NMDF Molar Cup #MoleDay @nationalmoleday
We love the chance to celebrate significant numbers. This punny holiday celebrates the mighty mole – One mole contains exactly 6.02214076×1023 elementary entities (approximately 602 sextillion or 602 billion times a trillion)[*], hence the celebration today! (starting at 6:02 am 10/23)
More from Mole.org:
Celebrated annually on October 23 from 6:02 a.m. to 6:02 p.m., Mole Day commemorates Avogadro’s Number (6.02 x 10²³), which is a basic measuring unit in chemistry. Mole Day was created as a way to foster interest in chemistry. Schools throughout the United States and around the world celebrate Mole Day with various activities related to chemistry and/or moles.
See more!
and more about the mole from *Wikipedia
https://blog.adafruit.com/2026/10/23/happy-mole-day-2026-nmdf-molar-cup-moleday-nationalmoleday/
https://cdn-blog.adafruit.com/uploads/2026/10/Screenshot-2024-10-23-at-10.18.36-AM.png
#rss #feeds #linksharing #qwibbit

2026-10-24 04:37:48 UTC

Adafruit New Products this Week
We’ve got the New nEw NEW for you right here
This week we debut 2 New Products.
Visit www.adafruit.com/new for more info.
Adafruit RV-8803 High Accuracy Real Time Clock Breakout Board – STEMMA QT / Qwiic
Adafruit Metro ESP32-P4 Hydra – with 16 MB PSRAM – v1 Chipset
https://blog.adafruit.com/2026/10/23/adafruit-new-products-this-week-4/
https://cdn-blog.adafruit.com/uploads/2018/05/Screen-Shot-2018-05-04-at-7.44.26-AM.png
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_new_products_hero-e1617299615525.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/6538-00.jpg
#newproducts #qwiicadafruit #breakoutboard #highaccuracy #accuracyreal #clockbreakout #realtime #chipset #hydra #metro
#rss #feeds #linksharing #qwibbit

2026-10-24 03:31:54 UTC

RepRapMicron Uses Fibre Optics To Print Tiny Benchy in Resin
The 0.5 mm Benchy made with the MicroRepRap UV head.
The RepRapMicron (also µRepRap) is pretty much the microscopic take on what RepRap did for more macroscale manufacturing, with the most recent innovation being a UV print head, called the PIKA UV Head. What this does is use off-the-shelf optical fiber and UV LED modules to create 3D structures in-situ in a UV resin, allowing for pretty small structures to be printed, down to a resolution of about 9 µm.
More photos of prints can be found on the blog page with links to YouTube videos. It’s naturally somewhat tricky to get clean photographs of a 3D print that’s small enough to lose forever if you so much as sneeze or breathe too loudly.
For the UV head assembly a single mode fiber optical cable was used in the form of a regular patch cord that got trimmed a bit with a hacksaw. This was used in combination with a “3W” UV LED module, which may or may not be its true rating, but it was definitely able to cure the SLA resin. The used resin was regular eSun Standard Resin.
Afterwards you have to do the typical SLA post-processing, including cleaning off of liquid resin – both the part and fiber – and curing the part. So far results are pretty decent, with overhangs still being a weak spot that will be addressed in future revisions.
https://hackaday.com/2026/10/23/reprapmicron-uses-fibre-optics-to-print-tiny-benchy-in-resin/
https://hackaday.com/wp-content/uploads/2026/10/microreprap_pika-uv-head_setup.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/microreprap_pika-uv-head_benchy.jpg?w=350
https://hackaday.com/wp-content/uploads/2026/10/microreprap_pika-uv-head_setup.jpg
#rss #feeds #linksharing #qwibbit

2026-10-24 02:22:04 UTC

ESP32 Jump Scares with The Haunted Box #ElectronicHalloween
Cytron Technologies posted up this guide for a haunted box using the Maker ESP32 board. A PIR sensor detects when someone passes by and the LEDs and servo motor (literally) jump into action. Music from a nearby laptop adds extra chills.
The Haunted Box is a motion-activated Halloween project developed using the Maker ESP32. When the PIR sensor detects movement, the system triggers a coordinated sequence: the servo motor creates physical movement, the RGB LED stick glows red, and a connected laptop plays horror audio. This project integrates motion detection, lighting, and sound to deliver an immersive, interactive experience.
See the full guide!
For more possessed parcels checkout our Motion Gift Box and Spooky Laughing Box
HAPPY HALLOWEEN! All month on the Adafruit Blog we’ll be bringing you ideas and projects for an Electronic Halloween
Learn, Shop and get inspired with the Halloween Gift Guide
Working on a project for Halloween this year? Let us know about it or tag us on socials!
https://blog.adafruit.com/2026/10/23/esp32-jump-scares-with-the-haunted-box-electronichalloween/
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_halloween2022_blog-2.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/1mb.png
https://cdn-learn.adafruit.com/guides/cropped_images/000/002/269/medium640mp4/hero-loop.mp4?1542053180
#rss #feeds #linksharing #qwibbit

2026-10-24 00:41:13 UTC

Make Your Electronic Halloween Ooze with Adafruit Feather RP2040 SCORPIO
If there is one thing Adafruit is known for, its mega-blinky-fun-rainbow-LEDs. We just love sticking NeoPixels anywhere and everywhere. When we saw the ‘PIO’ peripheral on the RP2040 from Raspberry Pi, we just knew it would be perfect for driving large quantities of NeoPixels. So we created this board, the Adafruit Feather RP2040 SCORPIO, designed specifically for NeoPixel (WS2812) driving but also good for various other PIO-based projects that want to take advantage of the Feather pinout with 8 separate consecutive outputs (or inputs).
Use SCORPIO to make it drip:
OOZE MASTER 3000: NeoPixel Simulated Liquid Physics
NeoPixels are beautiful. Let’s use them in something gross and icky!
Water Drip Dress with Oozemaster 3000
Create a magical flowing water effect for your costume
Holiday Icicle Lights with Flair
Step up your holiday lighting game with SCIENCE!
https://blog.adafruit.com/2026/10/23/make-your-electronic-halloween-ooze-with-adafruit-feather-rp2040-scorpio/
https://cdn-blog.adafruit.com/uploads/2026/10/adafruit_halloween_sale_2026_1920x1080.jpg
https://cdn-blog.adafruit.com/uploads/2026/10/ooze.gif
https://cdn-blog.adafruit.com/uploads/2024/09/Iled_pixels_oozemaster-thumb.gif
#adafruitfeather #ooze #scorpio #neopixels #liquidphysics #simulatedliquid #flairstep #iciclelights #drip #dripdress
#rss #feeds #linksharing #qwibbit

2026-10-24 00:04:24 UTC

Automatic Coil Winder Takes the Tedium out of Actuators
Anyone who’s ever built their own motors knows how tedious winding the coils soon becomes; in [Larry]’s case, the issue was even worse. He’s building his own flip-dot matrix display, and each dot uses two electromagnetic coils to flip a magnet in the dot. Rather than wind each of these by hand, therefore, he built his own coil-winding machine.
The coil winder uses two stepper motors: one to wind wire onto the bobbin, and one to move the wire guide carriage back and forth, distributing the wire evenly across the bobbin. The bobbin is held in place by a retainer, which doubles as a tie point for the end of the wire. The spool of wire rotates on a pair of bearings, and the wire is fed between two pieces of foam to provide adjustable tension. The housing is mostly 3D-printed, with some metal rods, bearings, and belt drives fleshing out the structure. On the electronics side, a Teensy controls the winder, with an OLED display and a rotary encoder for control. Before beginning on a coil, it homes the guide carriage against an end-stop switch, then winds on layers, keeping track of the number of layers applied.
We’ve seen a few coil winders here in the past, including a 3D printer adapted to winding stators. For more on this winder’s application, check out [Larry]’s flip-dot design.
https://hackaday.com/2026/10/23/automatic-coil-winder-takes-the-tedium-out-of-actuators/
https://hackaday.com/wp-content/uploads/2026/10/coil_winder.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/coil_winder.png
#windertakes #coilwinder #automaticcoil #actuators #larry
#rss #feeds #linksharing #qwibbit

2026-10-23 23:30:27 UTC

Subscribe to the Adafruit Youtube channel! #Youtube #AdafruitLearnSystem

Are you subscribed to the Adafruit Youtube channel? If you’re not already subscribed, click here! http://adafru.it/subscribe . It’s a free and easy way to keep up with our newest episodes. Here’s some of what we’re up to.
Electronics Show and Tell Wednesdays 7:30pm
Electronics show and tell every Wednesday at 7:30pm ET.
Adafruit Ask an Engineer LIVE 8pm Wednesday!
Every Wednesday night at 8pm ET join us for our weekly live video & chatroom! Visit http://adafruit.com/ask for more info. You can ask anything about electronics, kits at Adafruit or just stop in to meet other makers who are building cool things!
3D Hangouts – Thursdays
Hang out with Noe & Pedro Ruiz every week and discover 3D printing! Get your 3D news, projects, design tutorials, shop talk and more each week..
New Products – Updated Fridays
Each week Ladyada shows the newest great electronics at Adafruit!
Live from the desk of Ladyada
Join Ladyada streaming live for circuit board layout design, code writing, surface mount soldering and more fresh engineering and even some gaming! If Ladyada’s working on it, you’ll find it here first.
Chip Shortage
Chip Shortage includes videos about the ongoing chip shortage in the electronics industry. Adafruit founder Ladyada discusses the current state and highlights products that are hard to get or possibly “unobtainium”.
John Park’s Workshop
Project builds, hacks, and mods from John Park’s Workshop!
Advanced Manufacturing: Made in NYC by Adafruit!
This playlist highlights Adafruit manufacturing right here in NYC!
And so much more!
https://blog.adafruit.com/2026/10/23/subscribe-to-the-adafruit-youtube-channel-youtube-adafruitlearnsystem-226-4-3-3-2/
#rss #feeds #linksharing #qwibbit

2026-10-23 22:13:00 UTC

The Python on Microcontrollers Newsletter: subscribe for free
The Python for Microcontrollers Newsletter is the place for the latest news involving Python on hardware (microcontrollers AND single board computers like Raspberry Pi).
This ad-free, spam-free weekly email is filled with CircuitPython, MicroPython, and Python information that you may have missed, all in one place!
You get a summary of all the software, events, projects, and the latest hardware worldwide once a week, no ads! You can cancel anytime.
It arrives about 11 am Monday (US Eastern time) with all the week’s happenings.
And please tell your friends, colleagues, students, etc.
Please sign up > > >
https://blog.adafruit.com/2026/10/23/the-python-on-microcontrollers-newsletter-subscribe-for-free-10-23-2/
https://cdn-blog.adafruit.com/uploads/2026/10/cp11.jpg
https://cdn-blog.adafruit.com/uploads/2026/02/Subscribe-2026-02.jpg
https://pbs.twimg.com/media/GlSkmQPWAAMqzKE?format=png&name=small
#microcontrollersnewsletter #python #free #raspberry #please #monday #micropython
#rss #feeds #linksharing #qwibbit

2026-10-23 21:06:16 UTC

Reconstructing the Ancient Chinese Storm of Crows Weapon
The Chinese had been using large crossbows – akin to Greek and Roman ballistae – for warfare for many of the same reasons that European armies loved them. Their single, large arrow was effectively unstoppable, though this also was rather useless against large groups of infantry unless they were so kind to neatly line up. Old Chinese records mention a special kind of ammunition, called a cup arrow, or ‘storm of crows’, which involves launching many smaller arrows instead of a single large one, a feat that [Tod] really wanted to try and recreate.
In itself this doesn’t sound too complex: just grab some arrows, loosely tie them together in a bundle and slap them on the crossbow. Yet with the immense forces applied on this bundle it clearly turns out that the engineering challenge isn’t quite that straightforward, as the arrows love to scatter wildly in all directions or otherwise be rather unpredictable.
Although we can find historical references to multiple bolt siege crossbows being used, details are sparse on how the Chinese engineers addressed these aforementioned issues, so [Tod] tries a range of approaches to try and make it work on his own siege crossbow. Unfortunately he wasn’t able to make it work reliably, but he says he’ll be back with a range of improvements, with the community invited to pitch in their own ideas.
These type of weapons were very commonly used in China and surrounding nations from hundreds of years BCE to around the 16th century CE, when black powder was used to launch projectiles like fire arrows from a Huo Che or the Korean equivalent of the Hwacha, effectively multiple rocket launchers, not unlike the MLRS units seen in militaries today.
https://hackaday.com/2026/10/23/reconstructing-the-ancient-chinese-storm-of-crows-weapon/
https://hackaday.com/wp-content/uploads/2026/10/multi-missile_crossbow_launcher_tods_workshop_youtube.jpg?w=800
https://hackaday.com/wp-content/uploads/2026/10/multi-missile_crossbow_launcher_tods_workshop_youtube.jpg
#ancientchinese #crowsweapon #chinesestorm #oldchinese #tod #huoche #roman
#rss #feeds #linksharing #qwibbit

2026-10-23 20:32:08 UTC

Self-Hosted Game Vault
Store your game collection with this self-hosted vault from botchris. Check out the repo.
If you have played on PC and consoles for a while, your games are scattered: Steam, Epic, GOG, Battle.net, the EA app, Ubisoft Connect, Xbox, PlayStation, a pile of Humble Bundle keys you never redeemed, and shelves of discs. Before buying a game, or when a bundle hands you a key, it is hard to answer a simple question: do I already have it?
Game Vault puts your whole collection in one catalog. You run it yourself, on a home server, a NAS or your own computer (a single Docker container or program), and open it from the browser of any device: there is nothing to install on your phone and no account in anyone’s cloud.
https://blog.adafruit.com/2026/10/23/self-hosted-game-vault/
https://cdn-blog.adafruit.com/uploads/2026/10/home-600x375.jpg
#gamevault #ubisoftconnect #humblebundle #epic #gog #steam #xbox #docker #nas #playstation
#rss #feeds #linksharing #qwibbit

2026-10-23 19:23:54 UTC

Running a Philips CD-i Off USB-C
The Philips CD-i is a console with many shortcomings, and those include the power supply. For whatever reason, the engineering team decided it should use an 8P8C connector just like Ethernet. Thus, just like your Ethernet cables, it has that annoying problem of the tab snapping off all the time. [MattKC] wondered if the CD-i could benefit from a USB power upgrade instead, and set about making it a reality.
The plan was simple enough—get the CD-i running off of USB-C instead of the ungainly original power supply that shipped with the unit. Given the console runs almost exclusively off of 5 V power, it should have been pretty easy. Only, the original spec adds one little detail that makes things a bit harder. The console is designed to draw up to 3 A from the 5 V line, while also having a -5 V line at 0.2 A. If not for that negative supply, it would have been easy to run the unit off any old 15 W USB-C charger spitting out 5 V. That extra negative line complicates things, because while the negative line could be created with some supporting electronics, it’s hard to find that extra watt from most chargers. While there are plenty of higher-wattage USB-C chargers, the majority tend to use higher voltages to deliver the additional power, capping the 5 V output at 3 amps.
Thus, it was necessary to work a little harder. [MattKC] decided to build a board that would negotiate with a USB-C charger for 9 V operation to get the power budget necessary. This would then be stepped down to 5 V, while there would also be an inversion step to supply the -5 V line, too. A CH221K chip does the job of negotiating a 9 V USB-C power supply, while a TPSM84538 steps the voltage down to 5 V with the capacity to supply up to 5 A. An LT3580 chip then inverts this voltage for the 5 V line. There’s also a power switching circuit on board because the CD-i included some of that functionality in the original power brick.
If you’ve got a CD-i and you’re sick of fussing with the original power supply, this could be a great upgrade. We’ve also explored USB Power Delivery in detail before, if you need a primer.
https://hackaday.com/2026/10/23/running-a-philips-cd-i-off-usb-c/
https://hackaday.com/wp-content/uploads/2026/10/Running-the-Philips-CD-i-off-USB-C.-because-why-not_-14-54-screenshot.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/Running-the-Philips-CD-i-off-USB-C.-because-why-not_-14-54-screenshot.png
#power #usbpower #running #ethernet #powerdelivery
#rss #feeds #linksharing #qwibbit

2026-10-23 18:49:26 UTC

Automatic Mechanical Watch Winder #AdafruitLearnSystem
Autowinding mechanical watches are wonderful, they stay wound simply by wearing them. But what happens when you don’t wear it for a couple of days? It runs out of power as the mainspring fully unwinds. This means you need to re-set the time (and possibly the day/date) before wearing it again. But no more! This project is a watch winder to keep the auto-winder automatically wound!
This is accomplished using a small DC motor powered by a Circuit Playground Express and a Crickit board all programmed visually with MakeCode. Your watch will turn the proper number of times each day to keep it wound just the right amount. It uses a LEGO-compatible brick structure to gear it and support the whole contraption.
Check out the full guide!
https://blog.adafruit.com/2026/10/23/automatic-mechanical-watch-winder-adafruitlearnsystem/
https://cdn-blog.adafruit.com/uploads/2026/10/makecode_winder-8331-300x225.jpg
#rss #feeds #linksharing #qwibbit

2026-10-23 17:41:04 UTC

Hackaday Podcast Episode 392: Microscopes, Drones, and Other DIY Things
Hackaday Editors Elliot Williams and Al Williams met to review the week in Hackaday. Turns out, it was a week for tiny things, cybersecurity, nostalgia, and projects that would have been nearly impossible for the average hacker not that long ago. But first, you can hear a little about the upcoming Supercon badge and the trials of importing and exporting parts for the badges.
How many props does your drone have? [Joshua] has one. Want to fabricate semiconductors at home? Do you have a microwave? What about using NFC in your next project? There’s all that and more in this episode.
The quick hacks include a request from NASA for ideas (and, yes, there is prize money) and slide rule tricks, among other things. For the can’t miss articles, the cybersecurity weekly got some appreciation and Al took a trip down memory lane at the Altair 8800 he always wanted.
Check out the links if you want to follow along, and as always, tell us what you think about this episode in the comments, or drop us a line on the mailbag.
Download in DRM-free macroscopic MP3.
Where to Follow Hackaday Podcast
Places to follow Hackaday podcasts:
iTunes
Spotify
Stitcher
RSS
YouTube
Check
out our Libsyn landing page
Episode 392 Show Notes:
News:
Supercon Ten Tickets On Sale Now
The Trials And Tribulations Of Your First Badge
PHP2Shell — AI uncovers critical vulnerabilities in the backbone of the web
Mailbag:
Thanks to [Silver Dog Australia] for some new sting sounds for the podcast. Send us your sound, questions, or thoughts on the podcast for next week’s mailbag: mailbag@hackaday.com
Interesting Hacks of the Week:
Building A Flying Drone With A Single Propeller
Building And Flying A Helicopter With A Virtual Swashplate
Flies Like A Quadcopter, But This Drone Design Has Only One Propeller
One-Motor Drone Mimics Maple Seeds For Stability
Making Photovoltaic Solar Cells With A Microwave
A Stereo Vision Board For Hardware Hackers
I’m not putting a WiFi router into a phone charger (Part 3) – Rootkit Labs Blog
Stereo Vision And Depth Mapping With Two Raspi Camera Modules
High Performance Stereo Computer Vision For The Raspberry Pi
Tracking Bees With A Stereo Camera
Building The First Digital Camera
An Open Micro-Manipulator Improved
Building A Microscope With A 3D View
Birduino Plays Bird Calls On Demand With NFC-enabled Cards
Quick Hacks:
Elliot’s Picks:
NASA’s Lunar Ground Challenge is a Real Buzz
5 GHz Drone Video, With An ESP32
Going Whole-Hog On A First Satellite Ground Station
Al’s Picks:
Simplifying Slide Rule Calculations With Trig
An LCR Meter With Compromises
Visualize Regular Expressions With Marbles
Can’t-Miss Articles:
This Week In Security: Critical DNS Keys Rotated, Hacking Freezers Isn’t Cool, OpenAI Spies On Itself, And Advanced Hardware Wallet Hacks
The Age Of Altair
https://hackaday.com/2026/10/23/hackaday-podcast-episode-392-microscopes-drones-and-other-diy-things/
https://hackaday.com/wp-content/uploads/2016/05/microphone.jpg?w=800
https://hackaday.com/wp-content/uploads/2016/05/microphone.jpg
#hackadaypodcast #drone #followhackaday #diy #episode #stereovision #building #hacks #first #elliotwilliams
#rss #feeds #linksharing #qwibbit

2026-10-23 15:59:15 UTC

The MSX Gets A New Sound Expansion Cartridge
If we’re honest, there aren’t a whole lot of accessories coming out for the MSX computer line this holiday period. There is, however, a new sound expansion cartridge for the diehard fans out there, thanks to [Ricardo Suzuki].
It’s called the Misato MSX, and it’s a cartridge you can build yourself to give your computer a grander set of sound capabilities than it ever had before. At the heart of the cartridge lies the Yamaha YMF288, an OPN3 chip that offered three Software Sound Generator (SSG) channels, six FM channels, and six rhythm channels. Paired with a decent DAC chip, it provides deliciously rich synthesized sound very characteristic of that 1980s/1990s FM synthesis era. The cart can be used for play of a wide variety of OPN music, or creating your own compositions with the right software tools. Audio output can be had either from the stereo line out jack on the cart itself, or mixed down to mono and passed to the MSX’s internal mixer.
If you’ve got an MSX that is a little weedy in its sound capabilities, this cart could be just the thing you’re looking for. We’ve looked at some fun MSX machines before, too. If you’re cooking up your own upgrades for retro machines, don’t hesitate to let us know on the tipsline!
https://hackaday.com/2026/10/23/the-msx-gets-a-new-sound-expansion-cartridge/
https://hackaday.com/wp-content/uploads/2026/10/OPN3_Misato_Rev0.4_Prototype_Playing_OPNA_f5b641-e1792664678244.png?w=800
https://hackaday.com/wp-content/uploads/2026/10/OPN3_Misato_Rev0.4_Prototype_Playing_OPNA_f5b641-e1792664678244.png
#newsound #soundexpansion #expansioncartridge #msx #misatomsx #ricardosuzuki #soundgenerator #softwaresound
#rss #feeds #linksharing #qwibbit

2026-10-23 14:45:28 UTC

This Week in Security: Record Patch Tuesday, PHP’s Bad Time, The Oldest Vuln, AI Armies, and More
It’s no longer a proper month without Microsoft breaking its own record for security fixes, and October’s Patch Tuesday was no exception. Brian Krebs brings the roundup: more than 1,400 vulnerabilities fixed in a single batch, dwarfing September’s record of nearly 1,000, which itself was about ten times the normal monthly load. According to Tenable, Microsoft has now passed 4,000 CVEs for the year with two months still to go.
Only one of the fixes is for a vulnerability already being exploited in the wild: CVE-2026-96951, a security feature bypass in the Windows Shell affecting Windows 10, 11, and some Server versions. A .NET Framework bypass, CVE-2026-108398, was publicly disclosed before the patch, giving attackers a head start, and with modern AI tooling, it seems like not much of a head start is needed. At least 78 of the bugs are rated critical, and most of those allow remote code execution with little or no user interaction. Windows 10 holdouts can relax a little: Microsoft quietly extended free updates through October 2027. Given the pace of exploitation, this is probably the only way to prevent an Internet-scale meltdown.
Microsoft credits LLM-driven bug hunting for the volume, which leaves the poor admins who have to test and deploy all of this in an unenviable spot. Fortra’s analysis shows that only 26 Microsoft vulnerabilities have landed in the CISA KEV catalog of actively exploited bugs so far this year, so start there. For the rest, the SANS Internet Storm Center and Cisco Talos have the usual breakdowns by severity. Or, you know, just patch everything and hope for the best, which is roughly what everyone does anyhow.
The CA private key is… 4
Originally I was calling this the “big one” for the week, but this week that just keeps on giving. The private keys for eight eMudhra intermediate certificates have been compromised, and the way they were compromised is going to be a security talk punchline for years. Remember the Debian SSL and SSH key debacle? Of that scale.
Some background first. When your browser connects to a website over HTTPS, the site presents a certificate saying “I am example.com”, signed by a Certificate Authority (CA). Your browser and OS ship with a list of trusted root CAs, but roots are too valuable to use day to day, so they sign intermediate certificates, and the intermediates sign the actual website certificates. Whoever holds an intermediate’s private key can mint a certificate for any website, and every client that trusts the root will believe it. The whole system depends on those keys staying secret, and on them being generated properly in the first place.
eMudhra, an Indian CA which sells certificates under the emSign brand, had six TLS intermediates and two code-signing intermediates chaining to the emSign ECC Root CA – G3, which is trusted by Chrome and Apple, and Mozilla. A researcher identified only as Wayne proved the keys were compromised by signing the message “We have a problem here – Wayne” with each of them and sending it to the root programs.
How did Wayne get the keys? Flüpke posted one on Mastodon, and the secret value for the “EM OV TLS CA – G3C” key is… 4. Not four followed by 380 bits of randomness: the integer four. A reply quickly brute-forced the rest, and they’re all equally tiny: 56, 230, 237, 115, 155, 156, and 66. The keys were “incorrectly generated by the CA”, and anyone could recover them from the public certificates, which has been true since they were created in April 2025.
The browsers moved fast. According to The Hacker News, Chrome pushed a block within two hours of the report, and Mozilla blocked the certificates in under three, pulled the root from NSS, and shipped Firefox updates (CVE-2026-113470) for anyone with automatic updates disabled. There are no Certificate Transparency logs of rogue certificates, so modern browsers were never at risk. Everything that isn’t a browser is going to be the real problem and the extremely long tail of this fault: plenty of software never checks for revoked certificates and keeps trusting these keys until its bundled root list is updated.
Go hard-coded the eight bad keys into its standard library (CVE-2026-111943), but as Penligent points out, that only protects Go programs once they’re rebuilt with the new release. Python, Rust, Java, Node.js, curl, and most Linux distributions have updated root bundles, and the we-have-a-problem.com site has a full list, a checker, and manual workarounds for macOS, whose built-in curl and git don’t check revocation. There are also fixes for Linux, Windows, and the BSDs. Update everything, then go rebuild everything you compiled yourself. And then wonder how you’re going to update appliances, IoT devices, cameras, and everything else that fetches code over HTTPS or SSL.
php2shell: PHP gets owned by running out of memory
PHP, the language behind a significant percentage of the web had a rough week. WordPress, Drupal, Magento, phpMyAdmin, and just about every hosting control panel, major ecommerce sites, home project blogs, and even Hackaday itself was potentially impacted. Details of two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619, leaked onto Hacker News a day ahead of the embargo, and Huntress covers the scramble that followed as PHP rushed its release out early. Now that patches are available, Ryan Austin of Calif has published the full writeup, demonstrating pre-authentication remote code execution against important apps on default configurations, in PHP versions back to 5.4.0. That’s over a decade of PHP.
The trick is an old one, first found by Stefan Esser back in 2004. PHP enforces a memory limit for each request, and when a request exceeds it, PHP stops immediately with a fatal error. If that happens in the middle of native code updating some internal structure, the structure is left half-built, and the cleanup code that runs afterward trusts it anyhow. That’s a classic “use-after-free” style bug, where the program uses memory that’s already been released or was never properly set up, and those are frequently exploitable. Calif found ways to reliably push a request over the memory limit at exactly the right moment (deeply nested empty file uploads turn out to balloon into hundreds of megabytes of internal tables, while staying under PHP’s upload size limits), and three different places where the interruption leaves a dangerous mess. Austin found the first bug with a generally available LLM, but only because he knew PHP’s twenty-year history of memory-limit bugs well enough to point it in the right direction.
Amazon reports that its honeypots caught a php2shell exploitation attempt on October 17th, four days before the embargo lifted, and that it’s now being broadly exploited. Their advice is worth repeating: for critical bugs on internet-facing systems, measure your patch window in hours, not weeks, and start investigating from the earliest exploitation date, not the disclosure date. If you can’t patch right now, Calif suggests disabling session.upload_progress and removing the memory limit, which comes with its own obvious problems.
One word of caution: alongside the legitimate writeups, there are many self-published “corrected findings” and “proof-of-concept” posts that can’t seem to decide whether their own exploit works, while offering a downloadable “weaponized” bundle. A leaked-bug panic is the perfect time to hand anxious admins a zip file. Read the real advisories, and don’t run random proof-of-concept bundles.
A Sixteen-year-old forever-day in Broadcom WiFi
Quentin Kaiser has the long-form writeup of his Hexacon talk on a bug in Broadcom’s WiFi stack, present since at least 2010, which gives an attacker a root shell on a router from across the street. So called “parking lot” attacks that can happen from someone not even on your property have long been the boogeymen of WiFi security, and it’s been a little bit since we’ve gotten a new one.
The bug lives in WPS, WiFi Protected Setup: the “push the button on your router and then on your printer” pairing system that was supposed to save people from typing long WiFi passwords. WPS has a long and spotty security history, and this bug can be triggered over the air without knowing the network password, and without completing a WPS pairing. Kaiser’s demos show him pulling the WiFi password straight out of a router’s settings and sending it back over WiFi, and getting a fully interactive remote shell carried entirely over WiFi frames. No Internet connection required.
The really grim part is the patch history. Broadcom quietly released an incomplete fix in 2018, then suggested vendors switch to the open-source hostapd instead. For the older eCos-based chipsets that’s effectively never going to happen, which makes it a permanent “forever-day”. Broadcom refused to assign a CVE, and because Broadcom is its own CVE authority, CERT/CC closed Kaiser’s case the same day it was opened.
As of disclosure, the cable and DSL gateways he tested from three of Belgium’s four major ISPs were still vulnerable, and his napkin math puts it at over a million and a half devices in Belgium alone. Broadcom chips are, of course, sold everywhere. If you’re running ISP-provided hardware, there isn’t much you can do about the firmware. Turning off WPS can’t hurt if your router allows it, although Kaiser doesn’t say whether that blocks the attack. Disabling the gateway’s own WiFi and running your own access point that you can actually update is the safer bet.
GitLab regex bug reaches back twelve years
GitLab has released fixes for CVE-2026-110264, a maximum-severity CVSS 10.0 bug allowing unauthenticated attackers to run code on self-hosted GitLab servers. The flaw is an integer overflow when compiling a specially crafted regular expression in Onigmo, the Ruby regex engine which GitLab bundles into its own packages, so it affects every version back to GitLab 7.0 in 2014.
This is the fourth regex engine code execution bug from the same researcher in about a month (after CVE-2026-97229, CVE-2026-93577, and CVE-2026-89078), and comes with a nasty gotcha: the new fixed versions are one release past the October 12th fix, so if you diligently patched nine days ago, you’re vulnerable again. GitLab hasn’t said what’s needed to trigger the bug, so there’s no configuration workaround. If you’re running GitLab at home or in the shop, patch, and budget for some downtime while the database migrations run.
Node.js Brotli bug
Node.js shipped security updates for the 22, 24, and 26 branches, headlined by CVE-2026-111497, an out-of-bounds write in the bundled Brotli decompression library. Vercel’s advisory notes that researchers have demonstrated both memory leaks and command execution.
Node doesn’t decompress Brotli data on its own, but plenty of applications and libraries do, whether on incoming requests or on responses fetched from other servers. Vercel deployed firewall rules for traffic coming into its own platform, but no firewall can protect your code from a malicious response it goes and fetches itself. Node 20 is end-of-life and won’t be fixed. As a bonus, the same releases carry the eMudhra certificate distrust, so that’s two reasons to go update.
Header accordions and HTTP/3
HTTP/3 is the newest version of the protocol behind the web, running over QUIC (a UDP-based transport) instead of TCP. To save bandwidth, it compresses request headers using a scheme called QPACK: common headers can be sent as a one-byte reference into a table instead of the full text. Compression is great for bandwidth, but any time a small input can turn into a big output, there’s a risk of a “decompression bomb”. Similar tricks resulted in “zip bombs” in the 2000s, and what’s old is new again.
FoxIO found exactly that in seven of the ten HTTP/3 implementations they tested. One approach packs about 160,000 unique short headers into a single 1MB request; another stores one 4KB header and then references it thousands of times, a 4000-to-1 amplification. The HTTP/3 spec already says how to limit the decoded size, but implementations got it wrong in every possible way: checking only the compressed size, decompressing everything before checking, ignoring the per-header overhead, or reading the limit setting and then never enforcing it.
Fixed so far are quic-go (CVE-2025-64702), which is used by Caddy, Traefik, and Cloudflare’s tunnels; Cloudflare’s quiche (CVE-2026-12523); lsquic 4.9.0; and even Wireshark (CVE-2025-13945), whose QPACK decoder crashed during testing. Bun, the hyperium h3 Rust crate, and aioquic/mitmproxy remain unpatched. Bun gets special mention for an integer overflow that turns a single 516KB request into a permanent 100% CPU infinite loop. The lesson applies to any compression format: limit the decompressed size as you go, not just the bytes on the wire.
Metamorphic macOS ransomware
Patrick Wardle of Objective-See digs into Heartbreaker, macOS ransomware written in Rust that has sat on VirusTotal since May 2025, undetected by every antivirus engine.
Most antivirus detection relies on signatures: a hash or byte pattern identifying a known-bad file. Metamorphic malware tries to dodge signatures by rewriting itself so every copy looks different while behaving the same. Heartbreaker takes a delightfully brute-force approach: it carries its own Rust source code inside the binary, and after running, it shuffles variable names, adds junk functions, installs a Rust compiler if one isn’t present, recompiles itself, and replaces itself with the new build. It is about as subtle as a brick through a window.
As ransomware it’s not very scary. It only encrypts the Downloads folder, and uses the same hard-coded key for every victim, so Wardle simply wrote a decryptor. The rebuilding also depends on a GitHub library which has since disappeared, so it mostly fails anyhow. Wardle uses it to demonstrate his free RansomWhere? tool, which ignores signatures completely and instead watches for an untrusted process rapidly writing files that look encrypted (using a bit of entropy math). The malware can change its hash all day long, but to ransom anything it still has to encrypt the files, and that’s much harder to disguise.
UpdraftPlus vendor breached
TeamUpdraft, the company behind the very popular UpdraftPlus WordPress backup plugin, disclosed a breach of their customer database over the weekend. Names, emails, addresses, hashed passwords, and two-factor authentication settings were taken, and more worryingly, the connection keys for UpdraftCentral, their cloud dashboard for managing many WordPress sites at once. UpdraftPlus previously made an appearance back in June, when a vulnerability in the plugin was used in the Awesome Motive supply chain attack.
Those UpdraftCentral keys can send commands to every connected site, which turns one vendor breach into a remote control for potentially thousands of customer websites. TeamUpdraft has released UpdraftPlus 1.26.12 and 2.26.12, which automatically disconnect the old keys. If you or anyone you know manages WordPress sites through UpdraftCentral, log in to each site directly, update the plugin, and check for unexpected admin accounts and plugins (including the easy-to-miss “Must-Use” plugins tab).
Spyware delivered by ad network
Citizen Lab has published research showing that the Israeli ad-tech company Discover-Tech helped deliver spyware through ordinary online ads, targeting at least 45 devices at the news outlet Al Jazeera in 2024 and 2025. Citizen Lab attributes the spyware to Candiru, a commercial spyware vendor.
When you load a web page with ads, the ad slot is typically auctioned off in real time to the highest bidder, based on a profile of who you seem to be. This “programmatic advertising” system is, by design, a mechanism for running third-party content on a very specific person’s device. It’s easy to see why that’s attractive to a spyware vendor. According to Citizen Lab, Discover-Tech’s platform could profile users and infect a device just by displaying an ad, no click required. CPJ reports that the company’s ads reached nearly 200,000 websites and apps, and researchers at Confiant fo
https://hackaday.com/2026/10/23/this-week-in-security-record-patch-tuesday-phps-bad-time-the-oldest-vuln-ai-armies-and-more/
https://hackaday.com/wp-content/uploads/2016/01/darkarts.jpg?w=800
https://hackaday.com/wp-content/uploads/2016/01/darkarts.jpg
#patchtuesday #security #php #microsoft #windows #october #root #netframework #ai
#rss #feeds #linksharing #qwibbit