When the Internet first started gaining mainstream popularity in the late 90s, many optimists claimed that it would bring people together by reducing barriers to communication. That ideal hasn’t exactly come to pass yet, as anyone who has been on the Nextdoor neighborhood social network can likely attest to. Before social media, neighbors weren’t completely in the dark about their local communities, though. Besides word-of-mouth communication, there were also local access channels on cable TV, which had none of the downsides of modern social media. And [Hans] is bringing this style channel back.

[Hans]’s project is called CABLE 82, a bulletin board channel that matches the style of these channels from the 1980s. There’s better technology available for these types of systems now, though, so instead of relying on something like a character generator he’s using a Raspberry Pi running custom software to produce the video feed. The Pi hosts a web server so the 4:3 video feed can be reserved for the bulletin board display, but users who have older Pis with the yellow composite video output can skip using something like an HDMI to RF converter on their period-appropriate CRT displays. The software also adds sound functionality, as these channels always had some sort of elevator music playing while they were scrolling through local community news.

For those looking to recreate some of the nostalgia of 1980s community and technology, [Hans] has made this project open source, with all of the files on a GitHub page. Part of the reason [Hans] got interested in building something like this is that he had been trying to source a CRT television for retro gaming, and wanted to reproduce more of that era than just a few video games. A channel like this would be a great addition to a complete cable TV recreation build like this one, which even includes a preview channel of everything playing.

The lossy compression algorithm used by JPEG was useful for those on the early Internet not only because it enabled pictures to be shared easier, but because it allows a low-resolution version of the image to load first. This meant that users could make out the gist of an image before it finished downloading. This was a great feature for those on slow connections, but it hides some other capabilities of this image format as well.

Rather than effectively splitting up the image into chunks, each with successive amounts of detail, [maurycyz]’s project shows that this can be exploited to load more than one picture. The first is loaded into this lower-resolution area, with a second unrelated picture showing up once the higher-resolution information is available. Essentially this makes a one-way .gif of sorts. Though this method is only capable of loading about nine frames, which is not enough for much animation. Further limiting things is that there’s no way to encode timing data, so on fast computers with fast connections the animation could load faster than a user could see.

Still, it’s an interesting quirk of this older image standard, one which still is in widespread use today. And it’s also true that it’s hard to say in what ways various technologies will be used in the future. JPEG images have also been the subject of some artistic projects that might not have been possible without the JPEG standard itself, and even as other formats have tried to supplant it, it still maintains its firm grip on the images on the Internet. More JPEG, please!

One of the extra tools someone might need when working with surface-mount components is a solder paste stencil, which not only simplifies the application of solder paste to a PCB but increases accuracy. These metal stencils can cost an annoying amount of money and take time to get delivered, so this group has developed a method to 3D print them instead.

Starting with a PCB design in one’s tool of choice, the Gerber files can be sent to the online Stenchill tool to generate the stencil. Alternatively, a KiCad plugin exists as well. The tool will output files for a 3D printer from there. An FDM printer is required, with either PLA or PETG filament, and some configuration in the slicer is needed to get the accuracy required for a useful stencil. But once that’s all set up, the printer can output a perfectly usable stencil at a fraction of the cost, and without having to wait days for delivery through the mail.

It’s not all upside, though. Although it might be better than applying solder paste with a syringe on a massive board or doing more than one smaller board by hand, it may not be as good as a metal stencil for extremely small pads. But for those who often find themselves using metal stencils and dealing with the downsides that come with them, this could be a viable alternative, especially when prototyping.

If you have a laser cutter handy, that opens up some additional options for stencil production.

As technologies change and adapt, we’re often left with seemingly useless junk that has nowhere to go. Certainly anyone still sitting on a pile of floppy disks feels this way sometimes, but odds are anyone who owns a mining ASIC or an NFT can attest to that as well. The trillions of dollars flowing into GPU-based data centers will likely become the next victim of this trend, so if you want to capitalize on the losses of some venture capitalist you’ll want to figure out a way to get GPUs meant for a server into your desktop doing useful work.

Of course, calling these devices GPUs is a bit of a stretch compared to the Radeon and GeForce cards many of us are used to using for gaming. These don’t even have a PCIe slot or video output, after all. But, as [Oscar] notes, the VRAM and GPU cores are very real and can still do useful work. An adapter board is able to mate a Tesla V100 SXM2 16 GB GPU to a standard PCIe slot, which solves the first problem, but the major downside from there is that the cooling fan for this unit was literally deafeningly loud. At 82 dB it was about as loud as a lawnmower, which is fine in a server rack but not great in a bedroom. [Oscar] found a way to tamp down the fan speed, making it usable in a home.

Without video output, the utility of these cards mainly comes from adding VRAM and compute for tasks that benefit from parallel computing. Using tensor splitting, [Oscar] is running a local LLM with this card alongside his RTX 4080, providing 32 GB of VRAM on his NixOS system. With his benchmarking tests, the LLM sports impressive stats for a self-hosted model, ranking somewhere around Claude Sonnet 4.6. What’s even more impressive is that this is all done for around £200, and with the rate the various LLM companies are ratcheting up pricing could pay itself back very quickly. If trading off performance for cost is acceptable, though, it’s possible to run local models on much less powerful hardware as well.

At least in theory, video games are more resistant to becoming lost media thanks to their digital nature — they’re easy to copy and emulators have saved many titles that are otherwise locked in corporate vaults. But emulators give us something beyond simple preservation: they can also be used to enhance games well beyond the capabilities of the original systems while still preserving the souls of the games, as this NES emulator manages to do.

The emulator is called Anemoia-ESP32, and as its name suggests is a re-write of the Anemoia emulator specifically built for the ESP32. By modern standards these little chips don’t pack much of a punch, but compared to original NES hardware they’re more than up to the task of gaming. This project aims to recreate the Nintendo Entertainment System experience as faithfully as possible, hitting 60 FPS in most instances, as well as maintaining full audio emulation. Running on an ESP32 enables some truly small handheld options that would be difficult to achieve with more traditional platforms for emulation. There are some PCBs available here as well, but aren’t required to explore this project with.

As far as extra features compared to original NES hardware, the emulator does support save states and has a number of other settings improvements. Installation is as easy as flashing any other firmware image onto an ESP32, which these days can even be done from the browser. No word on whether or not it will eventually support emulating dual Picture Processing Units, but we can hope.

As more and more of the technology that we paid for turns becomes a subscription, there’s slowly been a momentum shift in the open source world of building replacements for these intrusive rent-seekers. We see this all of the time for self-hosted media and communications servers, but now we’re starting to see it in hardware as well. The OOMWOO robotic vacuum cleaner is completely open source, from hardware to software, and requires no cloud services whatsoever.

Although it’s open source, not every component is something one could buy off the shelf. It does require a 3D printer for most of the parts, but assuming that requirement is met most of the rest of the build comes together easily enough. For compute it relies on a Raspberry Pi running ROS 2 software and is set up to integrate easily with other existing open tools and projects such as Home Assistant. Like its proprietary cousins it can sense and map the rooms its placed in, but this platform uses an inexpensive 2D lidar system to keep costs down.

Right now the project is not quite complete, so we’ll all have to keep our eyes on this one as the team building it progresses. But they do have most of the software development done and the bill-of-materials is in progress. As an open project it’s being developed by many volunteers and there are a lot of areas available to contribute to as well, all currently set up on the project’s GitHub page. Right now many of those areas of effort are adapting the 3D printer files to off-the-shelf parts.

With the rocky status of the Roomba ecosystem, projects like this are more important than ever.

In an ideal world, the role of technology would be to make all of our lives easier. And although all the ads suddenly appearing in our smart TVs and gaming systems might make it seem otherwise, some technology can still improve our lives if we work hard at it. For [Cian], that meant training a neural network to read his gas meter so he wouldn’t have to do it himself.

The root issue here is twofold, first that [Cian]’s gas company hasn’t upgraded their own technology to modern, remote-readable meters, and second that the meter can’t be read by a gas employee because it’s hidden in the depths of [Cian]’s basement. This latter fact requires him to delve into Moria-like depths to get to the meter, so the solution here was to place a Raspberry Pi in this location instead. With a camera pointed at the meter, it’s not quite capable of discerning digits on its own so a neural network was trained in order to get accurate readings of the dial. And, finally, since the machine is networked already [Cian] set it up to automatically notify the gas company of its reading so he is now completely out of the loop.

For automating tedious tasks like these, the Raspberry Pi with something like OpenCV as a computer vision tool is a fairly mature platform for light machine learning duties like these. We’ve seen license plate readers as well as neighborhood traffic surveys built on these platforms to help automate human labor away, making our lives easier one single-board computer at a time.

If electronic paper displays have one downside, it’s generally refresh rate. Earlier versions of the tech might only have been able to do single-digit frames per second, while modern, mid-range devices can sometimes manage 10-20 FPS — and that’s not including the frames needed to blank the display. Getting up past that double-digit barrier typically requires higher-end displays, more powerful processors or FPGAs, and more money. On the other hand, [Tony] was recently able to get 20 FPS out of an ESP32-based device without using any extra processing power.

The key to improving e-paper performance is understanding how the display actually works. The “ink” consists of microscopic charged pigment particles that physically move in response to electric fields, making the display much slower than LCD or OLED panels. Rather than fully erasing and redrawing every frame, the software takes advantage of the particles’ existing state by generating optimized driving waveforms that only move the particles needed to produce the next image. On the software side, an MPEG-like encoding is used so only changes between frames are transmitted and converted into these waveforms, reducing unnecessary data transfers and allowing much higher frame rates.

Tony’s method is able to drive 960×540 panels, like those found in the Lilygo or M5PaperS3, to 20 FPS, and these platforms are based on nothing more than the capable but limited ESP32 chip. It’s an impressive push, and worth checking out the video in the linked project page. We assume you’d need a little more to drive something like the massive e-paper display found in this home automation setup, though.

A little over a month ago, we featured a project from [Igor] who built 64 bits of DRAM from scratch using discrete components. Jokes about memory pricing aside, he did have a use case for such a small amount of memory — he is using it in a custom-built drum machine. But featuring the memory build and not the drum machine was perhaps putting the cart before the horse, so in this video, [Igor] shows off the construction of each part of his impressive 16- or 64-step sequence drum machine.

This isn’t Igor’s first drum machine, either, although his previous build was a bit more limited. It had fewer steps in the sequence and didn’t quite have the range of his newer model. The upgraded version can play more steps but also includes force-sensitive drum pads based on piezo sensors and more voices (drums) as well. Each voice is built electronically using various op-amps and passive components, and [Igor] has the schematics for each of them, as well as every other part of the drum machine, for those looking to recreate any part of this on their own. There’s a lot going on in this lengthy video as well, so for the musically inclined, it’s worth taking a look in full.

Now that our horse is in the correct position in front of the cart, it’s worth going back and looking at the memory build if you missed it when it first ran. A small amount of memory makes the machine programmable rather than just playable, and truly expands the capabilities of a machine like this in the recording studio.

Back when Google ran a functional search engine, there used to be all kinds of quirky, fun antics hidden in their products. From Easter eggs in certain search results, to a flight simulator hidden in Google Maps, to funny, engaging April Fools jokes, it was a lighter, less corporate time. Now, though, to recreate any of that early Google magic, we have to do it on our own, and [Paul] has come up with an arcade cabinet for the classic Google Chrome dinosaur game that does just that.

Although the Dinosaur Game is still available in modern versions of Google Chrome, it lends itself almost perfectly to an arcade cabinet. Built from 18 mm plywood, the cabinet is standard DIY arcade fare with a built-in shelf to house the electronics and a 4:3 flatscreen monitor for a display. The Raspberry Pi 3B is also just enough to run the game, but the software running on it is unique. The Pi runs an operating system called FullPageOS, which automatically loads a modified version of the Dino jumper in full-screen mode. It’s been changed to look more like an arcade game than a browser Easter egg, with features like a leaderboard and an automatic-play screensaver mode, and the build is rounded out by a cactus-shaped scratching post to accompany the cabinet.

As for gameplay, we couldn’t ask for a simpler user interface. A single button is all that’s needed for this game, and it’s surprisingly engaging. It is a bit large for a single-button game, even with its reduced-width cabinet, so if you’re looking for something smaller, you could always base it on a tabletop arcade system instead.

About a month ago, [Greenhill Forge] built a few solar panels to collect energy from the sun. Unlike solar photovoltaics, which turn sunlight directly into electricity, these were designed to gather solar thermal energy with air. These types of panels can gather a tremendous amount of energy for a very low cost, and although the first video only went into the theory of their operation, his latest video actually shows us how to use that energy in a practical way.

The video starts by building a new solar panel, using upgraded materials and building methods compared to the previous versions which should improve the efficiency. There’s some data analysis of the performance, but at the end of the video [Greenhill Forge] actually hooks one of these up to a clothes dryer to explore its real-world efficacy. This process involves disconnecting the electric heater, removing one of the blower fans, and building a new flange to accept the heated air from the solar panel. A microcontroller keeps an eye on the incoming air temperature and controls a fan to try to hit the target temperature.

After an hour of drying, the test clothing was completely dry, with the only electricity used to turn the drum in the dryer. This is more than an order of magnitude of reduction in the power needed to dry clothes, which is fairly impressive. [Greenhill Forge] also notes that systems like these could augment off-grid systems not only for clothes drying but for home heating, greenhouse heating, or drying out various crops and that they could reduce strain on an electrical system that otherwise relies on resistive heating methods. There are many ways of building these panels, so be sure to check out his first video for ideas.