Our hacker [glgorman] sent in their submission for the One Hertz Challenge: an analog software clock for Microsoft Windows.

I guess we’d have to say that this particular project is a work-in-progress. There is no final clock, yet. But a number of yak’s have been shaved. For instance, we have code for computing geometric objects without using branch instructions, including points and lines and circles and such.

The notes dive deep into various rabbit holes. At one point we find ourselves computing the angle to the sun in the sky, that we may be able to cast the shadow of the clock hands on our clock face. The notes include miscellaneous source code snippets and various screenshots of geometric renderings which have been achieved so far.

We thought it was fun that the geometric software references Euclid’s Elements, which, as you probably know, is the famous geometry book from Ancient Greece, the second most published book of all time, second only to the Bible.

If you’re interested in analog clocks you might like this one which displays the date, not the time or this one which uses colors instead of hands.

hackaday.com/2025/08/04/2025-o…

Brilliant Labs have been making near-eye display platforms for some time now, and they are one of the few manufacturers making a point of focusing on an open and hacker-friendly approach to their devices. Halo is their newest smart glasses platform, currently in pre-order (299 USD) and boasting some nifty features, including a completely new approach to the display.
Development hardware for the Halo display. The actual production display is color, and integrated into the eyeglasses frame.
Halo is an evolution of the concept of a developer-friendly smart glasses platform intended to make experimentation (or modification) as accessible as possible. Compared to previous hardware, it has some additional sensors and an entirely new approach to the display element.

Whereas previous devices used a microdisplay and beam splitter embedded into a thick lens, Halo has a tiny display module that one looks up and into in the eyeglasses frame. The idea appears to be to provide the user with audio (bone-conduction speakers in the arms of the glasses) as well as a color “glanceable” display for visual data.

Some of you may remember Brilliant Labs’ Monocle, a transparent, self-contained, and wireless clip-on display designed with experimentation in mind. The next device was Frame, which put things into a “smart glasses” form factor, with added features and abilities.

Halo, being in pre-release, doesn’t have full SDK or hardware details shared yet. But given Brilliant Labs’ history of fantastic documentation for their hardware and software, we’re pretty confident Halo will get the same treatment. Want to know more but don’t wish to wait? Checking out the tutorials and documentation for the earlier devices should give you a pretty good idea of what to expect.

hackaday.com/2025/08/04/brilli…

ma è vera questa cosa?

facebook.com/share/p/16vx9ZEpK…

il passaggio sarebbe dunque dal colonialismo militare israeliano a quello economico della "World Bank"? i soldati del genocidio si ritirerebbero da Gaza? siamo sicuri?? e i coloni dalla Cisgiordania??? e poi, se capisco bene... quello palestinese dovrebbe essere l'unico stato al mondo a non avere nemmeno una cerbottana. no? e dovrebbe stare allegro e sereno e fidarsi di un confinante genocida che gli ha mutilato 100mila persone e uccise tra le 60mila e le oltre 300mila? e poi dovrebbe affidare il governo ai collaborazionisti di israele?

scusate lo scetticismo. forse sbaglio io. mi sforzo di capire. la notizia è fondata?

in generale, che ne pensate?

___

#Gaza #genocide #genocidio #Palestine #Palestina #warcrimes #sionismo #zionism #starvingpeople #starvingcivilians #iof #idf #colonialism #sionisti #izrahell #israelterroriststate #invasion #israelcriminalstate #israelestatocriminale #children #bambini #massacri #deportazione #concentramento #famearmadiguerra

One of the continuing struggles with FDM printing is making sure that parts that should fit together actually do. While adding significant tolerance between parts is an option, often you want to have a friction fit or at least a gap that you cannot drive a truck through. In a video by [Slant 3D] a number of tips and tricks to improve parts design with tolerance in mind are provided.

Starting with the fairly obvious, such as avoiding sharp corners, rounding off edges and using chamfered edges and filets for e.g. lids to make getting started easy, the video then moves into more advanced topics. Material shrinkage is a concern, which is where using thin walls instead of solid blocks of material helps, as does using an appropriate infill type. Another interesting idea is to use a compliant mechanism in the lid to get a friction fit without getting all print parameters just right.

On the opposing side to the lid – or equivalent part – you’d follow many of the same tips, with the addition of e.g. slots that allow for the part to flex somewhat. All of this helps to deal with any variability between prints, with the suggested grip fins at the end of the video being probably the most extreme.

youtube.com/embed/XKrDUnZCmQQ?…

hackaday.com/2025/08/04/how-to…

For those who experienced any part of the 1960s, even if it’s just experiencing the music from that era here in the future, the sound of the Mellotron is immediately recognizable. The Moody Blues were famous for using the tape-based instrument, and the Beatles and David Bowie produced hits with it as well. It’s haunting sounds are still highly prized today, but the complexity, cost, and maintenance requirement for the tape loops and other moving parts can put many musicians off from owning one. But [Japhy Riddle] has built an instrument without these downsides called the Tape Speed Keyboard.

Unlike the Mellotron which used a tape loop for each of its keys, the Tape Speed Keyboard uses only a single cassette tape. As the name implies, it changes the pitch of the sound by modulating the speed of the single tape housed in its own tape deck. The keyboard itself started off life as a Casio MT-35 but since this is a completely analog instrument, it was rewired so each key is connected to a potentiometer whose output voltage is tuned to a specific tape speed. [Japhy] reports that this is similar to tuning an analog piano and the process can be equally temperamental.

With everything electronic working, [Japhy] turned to making this a more acceptable musical instrument. Predictably, turning the motor on and off for each key press came with a bit of delay, causing the sound to come out goofy and muddy. To solve this problem he changed the design to make the tape play continuously rather than start and stop for a key press, and then modified other keys to be on-off switches for sound output. Since cassette tapes have two sides, he can also play either of two sounds in this way.

With the final polish on, the Tape Speed Keyboard is able to produce completely unique compositions that separate it from even the venerable Mellotron. Be sure to check out the video linked below to hear its sound. There have been plenty of other musical projects based around tape decks as well, including this one inspired by the original Mellotron and this tape deck-based guitar effects pedal.

Thanks to [splashbun] for the tip!

youtube.com/embed/adxlFwIGTfc?…

hackaday.com/2025/08/04/the-ta…

When building a model rocket, it can be fun to get into the maths of it all—calculating the expected performance of your build, and then seeing how it measures up in the real world. To aid in that task, [Rotislav Persion] has created a simple web-based simulator for charting the potential performance of your own rockets.

The calculator lets you key in the fundamentals of your hobby rocket. Punch in the diameter of your rocket, its mass, the standard rocket engine you’re using, and the diameter and delay time of your parachute, and it will chart the altitude profile expected during flight.

Punch in the details for a small 1-inch diameter rocket with an A8-5 engine, and you’ll find it won’t go very high or very far, and the calculator bears that out. However, upgrade to a C6 engine and you’ll go higher and faster, and drift a lot longer once the parachute is deployed.

Perhaps the only thing missing from the simulator is a wider variety of rocket engines to choose from, and more parameters to tweak for finer simulation. However, for small and basic rockets, it’s an interesting starting point you can use to learn about the basic mathematics and physics behind your rocket’s flight.

We’ve seen some great feats in model rocketry, not least of which was a valiant effort to master vertical landing. If you’ve got your own unique model rocket hacks cooking up in the lab, don’t hesitate to notify the tipsline!

hackaday.com/2025/08/04/a-simp…

Gli specialisti del Genians Security Center hanno scoperto una versione migliorata del malware RoKRAT, associato al gruppo nordcoreano APT37. La nuova versione si distingue per un insolito modo di nascondere il codice dannoso: nel corpo delle normali immagini JPEG. Questo approccio consente di bypassare i sistemi antivirus tradizionali, poiché la funzionalità dannosa non viene scritta direttamente sul disco, ma viene estratta nella RAM.

L’infezione iniziale inizia con l’avvio di un collegamento .LNK dannoso contenuto in un archivio ZIP. Un esempio è un archivio chiamato “National Intelligence and Counterintelligence Manuscript.zip”. La sua struttura include un file .LNK di grandi dimensioni (oltre 50 MB) che contiene documenti esca e componenti codificati: shellcode (ttf01.dat), script PowerShell (ttf02.dat) e file batch (ttf03.bat).

Quando il file viene eseguito, PowerShell viene attivato, utilizzando un XOR a un byte con la chiave 0x33, decrittografando lo shellcode a 32 bit. Il passaggio successivo prevede l’iniezione di un secondo livello di codice crittografato, che viene decrittografato all’offset 0x590 utilizzando la chiave 0xAE. Questo crea un file eseguibile contenente riferimenti a informazioni di debug, come il percorso “D:WorkUtilInjectShellcodeReleaseInjectShellcode.pdb”.

Il frammento decrittografato viene quindi iniettato in processi Windows legittimi come “mspaint.exe” o “notepad.exe” situati nella directory SysWOW64. Questa procedura crea una memoria virtuale in cui vengono scritti blocchi di dati di circa 892.928 byte. Questi vengono nuovamente decrittografati utilizzando XOR, questa volta con la chiave 0xD6. A questo punto, la parte principale di RoKRAT viene attivata.

Il file non viene salvato su disco, rendendo molto più difficile l’analisi post-infezione. I segnali di affiliazione ad APT37 includono timestamp del file, come 21 aprile 2025 alle 00:39:59 UTC, e costrutti univoci come “-wwjaughalvncjwiajs-“.

L’innovazione significativa è l’uso della steganografia. Il loader dannoso RoKRAT è incorporato in un’immagine JPEG, come “Father.jpg”, ospitata su Dropbox. Questo file conserva un’intestazione Exif valida, ma a partire dall’offset 0x4201 contiene uno shellcode codificato. Per estrarlo, viene utilizzata una doppia trasformazione XOR: prima con la chiave 0xAA, poi con 0x29. RoKRAT viene quindi caricato direttamente in memoria ed eseguito senza lasciare traccia sul file system.
Esempio di malware camuffato da file immagine
Per avviare il file DLL dannoso, vengono utilizzate tecniche di sideload tramite utility legittime, come ShellRunas.exe o AccessEnum.exe, incorporate nei documenti HWP. I download vengono effettuati da piattaforme cloud, tra cui Dropbox, pCloud e Yandex.Disk, utilizzando API e token di accesso scaduti, come ad esempio: “hFkFeKn8jJIAAAAAAAAAAZr14zutJmQzoOx-g5k9SV9vy7phb9QiNCIEO7SAp1Ch”.

Oltre a raccogliere informazioni e documenti di sistema, RoKRAT acquisisce screenshot e li invia a server esterni. Gli ultimi campioni, datati luglio 2025, sono distribuiti tramite scorciatoie come “Academy Operation for Successful Resettlement of North Korean Defectors in South Korea.lnk”. Queste versioni utilizzano già “notepad.exe” come processo di destinazione per l’iniezione e nuovi percorsi come “D:WorkWeapon” sono specificati all’interno del codice, a indicare il continuo perfezionamento del toolkit.

I sistemi di rilevamento e risposta agli endpoint (EDR) svolgono un ruolo importante nella protezione da tali attacchi. Queste soluzioni monitorano le attività insolite, tra cui iniezioni di codice e connessioni di rete alle API cloud. La visualizzazione tramite EDR consente di ricostruire l’intera catena di attacco, dall’avvio di LNK alla trasmissione dei dati al server di comando, nonché di isolare rapidamente la minaccia utilizzando la metodologia MITRE ATT&CK.

Con i metodi sempre più sofisticati dei gruppi APT basati sul diniego di accesso ai file e sul trasferimento occulto di dati, è chiaro che le tradizionali difese basate sulle firme non sono più sufficienti. Soprattutto quando vengono presi di mira i sistemi Windows in Corea del Sud e in altri paesi della regione.

L'articolo Il malware si camuffa in una foto innocente su Dropbox. La strategia steganografica di APT37 proviene da il blog della sicurezza informatica.

Originally known as FORTRAN, but written in lower case since the 1990s with Fortran 90, this language was developed initially by John Backus as a way to make writing programs for the IBM 704 mainframe easier. The 704 was a 1954 mainframe with the honor of being the first mass-produced computer that supported hardware-based floating point calculations. This functionality opened it up to a whole new dimension of scientific computing, with use by Bell Labs, US national laboratories, NACA (later NASA), and many universities.

Much of this work involved turning equations for fluid dynamics and similar into programs that could be run on mainframes like the 704. This translating of formulas used to be done tediously in assembly languages before Backus’ Formula Translator (FORTRAN) was introduced to remove most of this tedium. With it, engineers and physicists could focus on doing their work and generating results rather than deal with the minutiae of assembly code. Decades later, this is still what Fortran is used for today, as a domain-specific language (DSL) for scientific computing and related fields.

In this introduction to Fortran 90 and its later updates we will be looking at what exactly it is that makes Fortran still such a good choice today, as well as how to get started with it.

Modern Fortran

Punch card from a typical FORTRAN program by the early 1970s. (Credit: Arnold Reinhold, Wikimedia)
The release of the Fortran 90 (F90) specification in 1991 was the first major update to the language since Fortran 77, and introduced many usability improvements, as well as the dropping of punch card era legacy requirements and limitations to variable lengths and more. This is the reason for our focus on F90 here, as there is no real reason to use F77 or earlier, unless you’re maintaining a legacy codebase, or you have a stack of new cards that need punching. In case you are dying to know what changed, the Wikibooks Fortran Examples article has examples of early FORTRAN all the way to modern Fortran.

Of note here is that a modern Fortran compiler like GCC’s GFortran(forked from g95) still supports F77, but users are highly encouraged to move on to Fortran 95, a minor update to F90, with GFortran supporting up to F2008, with coarray support, as covered later. F2018 support is still a work in progress as of writing, but many features are already available.

Support for the latest standard (F2023) is not widely available yet outside of commercial compilers, but as a minor extension of F2018 it should eventually get rolled into those features as the implementation progresses. This means that for now F2008 is the latest standard we can reliably target across toolchains with new Fortran code.

Beyond GFortran there are a few more options, including Flang in LLVM and LFortran in addition to a gaggle of commercial offerings. Unless you intend to run high-performance computing code on massive parallel clusters like supercomputers, the GNU and LLVM offerings will probably suffice. Simply fetch either GFortran or Flang from your local package manager or equivalent and you should be ready to start with programming in Fortran.

Hello World

As with most DSLs, there is very little preamble to start writing the business logic. The ‘Hello World’ example is most succinct:
program helloworld
print *, "Hello, World!"
end program helloworld
The program name is specified right after the opening program keyword, which is repeated after the closing end program. This is similar to languages like Ada and Pascal. The program name does not have to match the name of the file. Although there’s no explicit specification for what the file extension has to be for a Fortran source file, convention dictates that for F77 and older you use .f or .for, while F90 and newer uses generally .f90 as extension. Although some opt to use extensions like .f95 and .f03, this is rather confusing, isn’t recognized by all compilers and all of those are similar free-form Fortran source files anyway.

Tl;dr: Use .f90 for modern Fortran source files. Our Hello World example goes into a file called hello_world.f90.

The other point of note in this basic example is the print command, which looks somewhat cryptic but is quite easy. The first argument is the format, reminiscent of C’s printf. The asterisk here simply means that we use the default format for the provided value, but we could for example print the first string as an 11 character wide field and a variable string as 8 wide:
character(len=8) :: name = 'Karl'
print '(a11,a8)', 'My name is ', name
This also shows how to declare and define a variable in Fortran. Note that if you do not start the code with implicit none, variable names that start with I through N are considered to be integer type and real otherwise. With gfortran you can also globally do this by compiling with the -fimplicit-none flag.

A total of five basic types are supported:

• real
• integer
• logical (boolean)
• complex
• character

Finally, comments in Fortran are preceded by an exclamation mark !. It’s also relevant to note that Fortran – like all good programming languages – is case insensitive, so you can still write your Fortran code like it’s F77 or Fortran II, yelling in all caps without anyone but the people reading your code batting an eye.

Hello Science

Now that we have got a handle on the basics of Fortran, we can look at some fun stuff that Fortran makes really easy. Perhaps unsurprisingly, as a DSL that targets scientific computing, much of this fun stuff focuses around making such types of computing as easy as possible. Much of this can be found in the intrinsic procedures of Fortran, which make working with real, integer and complex values quite straightforward.

For example, conjugating a complex number with conjg:
(Credit: Fortran Wiki)
Basically, whatever mathematical operation you wish to perform, Fortran should have you covered, allowing you to translate your formulas into a functional program without having to bother with any dependencies or the like. This includes working with matrices and getting into the weeds with numerical precision.

Even better is that you’re not stuck running your code on a single CPU core either. Since Fortran 2008, Coarray Fortran (CAF) is now part of the specification. This feature enables parallel processing, which is generally implementing on top of the Message Passing Interface (MPI) protocol, with gfortran implementing CAF support. Depending on the selected option with the -fcoarray= flag, gfortran can use the ‘single’ image (thread) option, or with a library like OpenCoarrays it can use MPI, GASNet, and others.

When using CAF with MPI, the program (‘image’) is distributed across all nodes in the MPI cluster per its configuration, with synchronization occurring as defined by the program. With OpenCoarrays available from many local OS repositories, this means that any budding molecular scientist and astrophysicists can set up their own MPI cluster and start running simulations with relatively very little effort.

The DSL Life

Much like when we looked at COBOL, a DSL like Fortran is often misunderstood as ‘yet another programming language’, much like how in the 1980s some thought that the scientific and engineering communities were going to switch over to Pascal or Modula-2. One simple reason that didn’t happen lies in the very nature of DSLs, with them being developed explicitly to deal with that specific domain. It will always be possible to do everything a DSL does in any generic programming language, it’s just that a DSL can be optimized more exactly, and is often easier to maintain, since it is not generic.

There are many things that Fortran does not have to concern itself with, yet which haunt languages like C and its kin. Meanwhile, reimplementing Fortran in C would come at considerable cost, run into certain limitations of the language and potentially require compromises in order to get close to the original functionality of the DSL.

Running a cluster with Coarray-based Fortran source, churning through complex simulations that require utmost control over precision and where one small flaw can waste days of very expensive calculations, those are the kind of scenarios where you’re not looking for some generic language to poorly reinvent the wheel, but where you keep using the same – yet much more refined – wheel that has gotten us this far.

hackaday.com/2025/08/04/a-gent…

Steve and James discuss ICE (et. al.) actions, how they are becoming a secret police force and why we need to get rid of them.

youtube.com/embed/SM6kGmzkUFA?…

Sign up to our newsletter to get notified of new events or volunteer. Join us on:

• Mastodon;
• Facebook;
• Blue Sky;
• Twitter.

Some links we mentioned:

• MassPirates 2025 Administrative Coup Memory Bank;
• The IRS Is Building a Vast System to Share Millions of Taxpayers’ Data With ICE;
• 26 USC 6103: Confidentiality and disclosure of returns and return information;
• Immigration agents demand tenant information from landlords, stirring questions and confusion;
• Flight Manifests Reveal Dozens of Previously Unknown People on Three Deportation Flights to El Salvador;

Image Credit: Public Domain via Wikipedia Commons

masspirates.org/blog/2025/08/0…

Three-axis 3D printing has been with us long enough that everybody knows the limitations, but so far, adding extra axes has been very much a niche endeavor. [Daniel] at Fractal Robotics wants to change that, with the Fractal 5 Pro 5-axis printer, and its corresponding Fractal Cortex slicer.

The printer looks like an extra-beefy Voron from a distance, which is no surprise as [Daniel] admits to taking heavy inspiration from the Voron Trident. The Fractal 5 shares a core-XY geometry with the Voron, using beefy 30 mm x 30 mm extrusions. Also like the Voron, it runs Klipper on a Raspberry Pi hiding in the base. Under a standard-looking printhead using a BondTech extruder and E3D volcano hotend, we find the extra two axes hiding under the circular build plate. The B axis is a gantry that can pivot the build plate assembly a full 90 degrees; the A axis spins the plate without limit thanks to the slip rings built into the design.

The extruder may look fairly normal, but it has actually been designed very carefully to allow the nozzle to get as close as possible to the build plate when the B-axis is at 90 degrees. It looks like the E3D hotend is actually the limiting factor there, which gives plenty of design freedom when planning prints in the accompanying Fractal Cortex slicer.

Fractal Cortex is an all-new slicer written entirely in Python. It does have a 3-axis legacy mode, but it’s primarily designed for 5-axis slicing with the Fractal 5 Pro. The multi-axis operation looks very straightforward: you place “slicing planes” and orient them along the part, as many as you require. Printing pauses while the A and B axes rotate, then resumes with straight, parallel layers. Sure, non-planar slicing would be the bees’ knees on this sort of 5-axis printer, but we’ve got to say for a young engineer’s first crack at this kind of software, Fractal Cortex looks pretty good.

It sounds like [Daniel] is looking for contributors to the project, so if this project tickles your fancy, head over to the GitHub links at the top of the page and dive in.

We’ve seen other 5D printers before, but this one probably takes the cake for build volume, and having a slicer to match is a big advantage for anyone who wants to try this at home.

Thanks to [Hari] for the tip. Use all your axes to extrude your projects into our tips line here.

youtube.com/embed/2_BY-7XOgWg?…

hackaday.com/2025/08/04/open-s…