A major bottleneck with high-frequency wireless communications is the conversion from radio frequencies to optical signals and vice versa. This is performed by an electro-optic modulator (EOM), which generally are limited to GHz-level signals. To reach THz speeds, a new approach was needed, which researchers at ETH Zurich in Switzerland claim to have found in the form of a plasmonic phase modulator.

Although sounding like something from a Star Trek episode, plasmonics is a very real field, which involves the interaction between optical frequencies along metal-dielectric interfaces. The original 2015 paper by [Yannick Salamin] et al. as published in Nano Letters provides the foundations of the achievement, with the recent paper in Optica by [Yannik Horst] et al. covering the THz plasmonic EOM demonstration.

The demonstrated prototype can achieve 1.14 THz, though signal degradation begins to occur around 1 THz. This is achieved by using plasmons (quanta of electron oscillators) generated on the gold surface, who affect the optical beam as it passes small slots in the gold surface that contain a nonlinear organic electro optic material that ‘writes’ the original wireless signal onto the optical beam.

hackaday.com/2025/04/14/plasmo…

Amazing as volumetric displays are, they have one major drawback: interacting with them is complicated. A 3D mouse is nice, but unless you’ve done a lot of CAD work, it’s a bit unintuitive. Researchers from the Public University of Navarra, however, have developed a touchable volumetric display, bringing touchscreen-like interactions to the third dimension (preprint paper).

At the core, this is a swept-volume volumetric display: a light-diffusing screen oscillates along one axis, while from below a projector displays cross-sections of the scene in synchrony with the position of the screen. These researchers replaced the normal screen with six strips of elastic material. The finger of someone touching the display deforms one or more of the strips, allowing the touch to be detected, while also not damaging the display.

The actual hardware is surprisingly hacker-friendly: for the screen material, the researchers settled on elastic bands intended for clothing, and two modified subwoofers drove the screen’s oscillation. Indeed, some aspects of the design actually cite this Hackaday article. While the citation misattributes the design, we’re glad to see a hacker inspiring professional research.) The most exotic component is a very high-speed projector (on the order of 3,000 fps), but the previously-cited project deals with this by hacking a DLP projector, as does another project we’ve covered.

While interacting with the display does introduce some optical distortions, we think the video below speaks for itself. If you’re interested in other volumetric displays, check out this project, which displays images with a levitating styrofoam bead.

youtube.com/embed/4wwKOXxX9Ck?…

[Thanks to Xavi for the tip!]

hackaday.com/2025/04/14/elasti…

There’s something cool about the visual design language used in the aviation world. You probably don’t get much exposure to it if you’re not regularly flying a plane, but there are other ways you can bring it into your life. A great example would be building an aviation-themed clock, like this stylish timepiece from [oliverb.]

The electronic heart of the build is an ESP32. This wireless-capable microcontroller is a popular choice for clock builds these days. This is because it can contact network time servers out of the box, which allows you to build an incredibly capable and accurate clock without any additional parts. No real-time-clock needed—just have the ESP32 buzz the Internet for an accurate update on the regular!

As for the display itself, three gauges show hours, minutes, and seconds on aviation-like gauges. They’re 3D-printed, which means you can build them from scratch. That’s a touch easier than having to go out and source actual surplus aviation hardware. Each gauge is driven by a NEMA17 stepper motor. There’s also an ATMEGA328 on hand to drive a 7-segment gauge on the seconds display, and a PIR sensor which shuts the clock down when nobody is around to view it.

It’s a tidy build, and one with a compelling aesthetic at that. We’ve seen some similar builds before using real aviation gauges, too. Video after the break.

youtube.com/embed/pB9JtX6nKLQ?…

hackaday.com/2025/04/14/esp32-…

The C64 Mini is a beautiful and functional replica of the most popular computer ever made, except at 50% size and without a working keyboard. For maximum nostalgia, it was modeled after the brown breadbox C64 case which so characterized the model. However, [10p6] wanted to build a tiny C64C instead, so set about making a conversion happen.

The build is primarily about the case design. [10p6] created a nice 50% scale duplicate of the C64C, with an eye to making it work with the internals of the popular C64 Mini. The case was paired with a custom PETSCII keyboard PCB and keycaps designed by [Bleugh]. This was a key element, since it wouldn’t really feel like a functional C64C without a functional keyboard. The build also scored a bonus USB hub for more flexibility. For the best possible finish, the case, power button, and keycaps were all printed using a resin printer, which provides a more “production-like” result than FDM printers are capable of.

It’s funny how retro computers remain popular to this day, particularly amongst the hacker set. In contrast, we don’t see a whole lot of people trying to replicate Pentium II machines from the mid-1990s. If you do happen to have a crack at it, though, the tipsline is always open. Video after the break.

youtube.com/embed/CwKFFWvBH-g?…

hackaday.com/2025/04/14/conver…

The best kind of Hackaday posts are the ones where there was some insurmountable problem with an elegant solution devised through deep analysis of the problem and creativity. This is not one of those posts. I’m sure you are familiar with bit rot. You know, something works for a long time and then, for no apparent reason, stops working. Well, that has been biting me, and lacking the time for the creative, elegant solution, I decided to attack it with a virtual chainsaw.

It all started with a 2022 Linux Fu about using autokey.

The Problem

I use autokey to give me emacs-style keystrokes in Web browsers and certain other programs. It intercepts keystrokes and translates them into other keystrokes. The problem is, the current Linux community hates autokey. Well, that’s not strictly true. They just love Wayland more. One reason I won’t switch from X11 is that I haven’t found a way to do something like I do with autokey. But since most of the powers-that-be have decided that X11 is bad and Wayland is good, X11 development is starting to show cracks.

In particular, autokey isn’t in the normal repositories for my distro anymore (KDE Neon). Of course, I’ve installed the latest version myself. I’m perfectly capable of doing that or even building from source. But lately, I’ve noticed my computer hangs, especially after sleeping for a long time. Also, after a long time, I notice that autokey just quits working. It is running but not working and I have to restart it. The memory consumption seems high when this happens.

You know how it is. Your system has quirks; you just live with them for a while. But eventually those paper cuts add up. I finally decided I needed to tackle the issue. But I don’t really have time to go debug autokey, especially when it takes hours for the problem to manifest.

The Chainsaw

I’ll say it upfront: Finding the memory leak would be the right thing to do. Build with debug symbols. Run the code and probe it when the problem comes up. Try to figure out what combination of X11, evdev, and whatever other hocus pocus it uses is causing this glitch.

But who’s got time for that? I decided that instead of launching autokey directly, I’d launch a wrapper script. I already had autokey removed from the KDE session so that I don’t try to start it myself and then get the system restaring it also. But now I run the wrapper instead of autokey.

So what does the wrapper do? It watches the memory consumption of autokey. Sure enough, it goes up just a little bit all the time. When the script sees it go over a threshold it kills it and restarts it. It also restarts if autokey dies, but I rarely see that.

What’s Memory Mean?

The problem is, how do you determine how much memory a process is using? Is it the amount of physical pages it has? The virtual space? What about shared libraries? In this case, I don’t really care as long as I have a number that is rising all the time that I can watch.

The /proc file system has a directory for each PID and there’s a ton of info in there. One of them is an accounting of memory. If you look at /proc/$PID/smaps for some program you’ll see something like this:
00400000-00420000 r--p 00000000 fd:0e 238814592 /usr/bin/python3.12
Size: 128 kB
KernelPageSize: 4 kB
MMUPageSize: 4 kB
Rss: 128 kB
Pss: 25 kB
Pss_Dirty: 0 kB
Shared_Clean: 128 kB
Shared_Dirty: 0 kB
Private_Clean: 0 kB
Private_Dirty: 0 kB
Referenced: 128 kB
Anonymous: 0 kB
KSM: 0 kB
LazyFree: 0 kB
AnonHugePages: 0 kB
ShmemPmdMapped: 0 kB
FilePmdMapped: 0 kB
Shared_Hugetlb: 0 kB
Private_Hugetlb: 0 kB
Swap: 0 kB
SwapPss: 0 kB
Locked: 0 kB
THPeligible: 0
VmFlags: rd mr mw me sd
00420000-00703000 r-xp 00020000 fd:0e 238814592 /usr/bin/python3.12
Size: 2956 kB
KernelPageSize: 4 kB
MMUPageSize: 4 kB
Rss: 2944 kB
Pss: 595 kB
Pss_Dirty: 0 kB
Shared_Clean: 2944 kB
Shared_Dirty: 0 kB
Private_Clean: 0 kB
Private_Dirty: 0 kB
. . .

Note that there is a section for each executable and shared object along with lots of information. You can get all the PSS (proportional set size) numbers for each module added together like this (among other ways):

cat /proc/$PID/smaps | grep -i pss | awk '{Total+=$2} END { print Total}'

Building the Chainsaw

So armed with that code, it is pretty easy to just run the program, see if it is eating up too much memory, and restart it if it is. I also threw in some optional debugging code.
#!/bin/bash
#- Run autokey, kill it if it gets too big
#- what's too big? $MLIMIT
MLIMIT=500000
#- how often to check (seconds)
POLL=10

#- Print debug info if you want
function pdebug {
#- comment out if you don't want debugging. Leave in if you do
#- echo $1 $2 $3 $4
}

while true # do forever
do
PID=$(pgrep autokey-qt) # find autokey
pdebug "PID",$PID
if [ ! -z "$PID" ] # if it is there
then
# get the memory size
PSS=$(cat /proc/$PID/smaps | grep -i pss | awk '{Total+=$2} END { print Total}')
pdebug "PSS", $PSS
echo $PSS >>/tmp/autokey-current.log
# too big?
if [ "$PSS" -gt "$MLIMIT" ]
then
pdebug "Kill"
echo Killed >>/tmp/autokey-current.log
# save old log before we start another
cp /tmp/autokey-current.log /tmp/autokey-$PID.log
kill $PID
PID=
sleep 2
fi
fi
if [ -z $PID ]
then
# if died, relaunch
pdebug "Launch"
autokey-qt & 2>&1 >/tmp/autokey-current.log
fi
pdebug "Sleep"
sleep $POLL
done

In practice, you’ll probably want to remove the cp command that saves the old log, but while troubleshooting, it is good to see how often the process is killed. Running this once with a big number gave me an idea that PSS was about 140,000 but rising every 10 seconds. So when it gets to 500,000, it is done. That seems to work well. Obviously, you’d adjust the numbers for whatever you are doing.

Bad Chainsaw

There are lots of ways this could have been done. A systemd timer, for example. Maybe even a cgroup. But this works, and took just a few minutes. Sure, a chainsaw is a lot to just cut a 2×4, but then again, it will go through it like a hot knife through butter.

I did consider just killing autokey periodically and restarting it. The problem is I work odd hours sometimes, and that means I’d have to do something like tie it to the screensaver. But I agree there are dozens of ways to do this, including to quit using autokey. What would your solution be? Let us know in the comments. Have you ever resorted to a trick this dirty?

hackaday.com/2025/04/14/linux-…

dalla pagina di Roberto Vallepiano
(grazie a Tano D'Amico)

facebook.com/share/p/1AZRzkFwZ…

Mancavano pochi minuti alla mezzanotte quando la prima manganellata si abbatté sulla spalla sinistra di Mark Covell, il giornalista inglese che stava dormendo alla Scuola Diaz assieme ad altri 92 mediattivisti di diverse parti del mondo.
Covell urlò in italiano che era un giornalista, ma in pochi secondi si trovò circondato dagli agenti dei reparti antisommossa che lo tempestarono di colpi dei Tonfa, i manganelli "spaccaossa" inaugurati proprio in occasione del G8 di Genova.
Riuscì a restare in piedi solo per pochi secondi, poi una bastonata sulle ginocchia gli spappolò una rotula e lo fece crollare sul selciato.
Mentre giaceva faccia a terra nel buio, contuso e spaventato, un'orda di 346 Poliziotti stava dando il via a quella che venne presto ribattezzata la "Macelleria Messicana".
Proprio in quel momento un agente gli saltò addosso e gli diede un calcio al petto con tanta violenza da incurvargli tutta la parte sinistra della gabbia toracica, rompendogli una mezza dozzina di costole. Le schegge gli lacerarono la pleura del polmone sinistro.
Mentre i battaglioni punitivi della Polizia iniziavano il massacro della Diaz, alcuni agenti cominciarono a colpire Covell con gli anfibi, passandoselo da uno all'altro, come se fosse un pallone da calcio.
Mentre avveniva ciò Mark Covell, che è alto 1,73 e pesa 50 chili, sentiva gli agenti ridere.
Una nuova scarica di calci gli ruppe la mano sinistra con cui tentava di proteggersi e gli danneggiò in maniera irreversibile la spina dorsale.
Rimase qualche minuto inebetito a terra in una pozza di sangue. Poi due poliziotti tornarono indietro e si fermarono accanto al giornalista inglese ormai semi-incosciente, uno lo colpì alla testa con il manganello e il secondo lo prese a calci sulla bocca, frantumandogli i denti. Mark Covell svenne.
Rimase sospeso tra la vita e la morte, in coma, per 15 lunghissime ore.
Arrivò in sala operatoria in condizioni disperate: trauma cranico con emorragia venosa, mano sinistra e 8 costole fratturate, perforazione del polmone, trauma emitorace, spalla e omero, oltre alla perdita di 16 denti.
Mark Covell è un sopravvissuto. Uno dei tanti sopravvissuti alla mattanza genovese nei giorni del G8, a quella che perfino Amnesty International denunciò come "La più grave violazione dei diritti umani in Europa dopo la 2° Guerra Mondiale".

E anche se la Corte di Strasburgo ha condannato l'Italia per tortura e trattamenti disumani e degradanti, nessuno o quasi ha pagato.
La verità è stata insabbiata e i responsabili della Premiata Macelleria Messicana sono stati tutti coperti trasversalmente dai governi di Destra e di Centrosinistra e addirittura promossi.

Ma noi siamo ancora qui. Oggi come ieri.
Fianco a fianco con Mark Covell e tutti gli altri.
Per sputargli in faccia la verità e ricordargli che la memoria è un ingranaggio collettivo.

Cosa c’è nel “decreto Sicurezza” appena entrato in vigore.

Voglio vedere se con un eventuale prossimo governo guidato da chi oggi sta all'opposizione queste norme saranno abolite oppure ormai ci sono e ce le terremo per sempre.

ilpost.it/2025/04/13/decreto-l…