Creating strong permanent magnets without using so-called rare earth elements is an ongoing topic of research. An interesting contestant here are iron nitride magnets (α”-Fe₁₆N₂), which have the potential to create permanents magnets on-par with with neodymium (Nd₂Fe₁₄B) magnets. The challenging aspect with Fe-N magnets is their manufacturing, with recently [Ben Krasnow] giving it a shot over at the [Applied Science] YouTube channel following the method in a 2016 scientific paper by [Yanfeng Jiang] et al. in Advanced Engineering Materials.

This approach uses a ball mill (like [Ben]’s planetary version) with ammonium nitrate (NH₄NO₃) as the nitrogen source along with iron. After many hours of milling a significant part of the material is expected to have taken on the α”-Fe₁₆N₂ phase, after which shock compaction is applied to create a bulk magnet. After the ball mill grinding, [Ben] used a kiln at 200°C for a day to fix the desired phase. Instead of shock compaction, casting in epoxy was used as alternative.

We have covered Fe-N magnets before, along with the promises they hold. As one can see in [Ben]’s video, oxidation is a big problem, with the typical sintering as with other magnet types not possible either. Ultimately this led to the resulting magnet being fairly weak, with a DIY magnetometer used to determine the strength of the created magnet.

Interestingly, there’s a much newer paper by [Tetsuji Saito] et al. from 2024 in Metals that does use sintering, specifically spark plasma sintering with dynamic compression (SPS-DC). SPS-DC can be done at fairly low temperatures (373 – 573 K, or 99.85 – 299.85 °C), producing much stronger magnets than [Ben] accomplished.

Although Fe-N magnets hold a lot of promise, they have lower coercivity. This means that they demagnetize easier, which is another aspect that weighs against them. For now it would seem that we aren’t quite ready to say farewell to Nd-Fe-B magnets.

youtube.com/embed/M6XIgdS1rzs?…

hackaday.com/2025/06/19/iron-n…

Nel noto marketplace underground Exploit.in, il threat actor chestniybro ha messo all’asta un accesso RDP a una non meglio identificata azienda italiana operante nel settore retail di gioielli e orologi.

Secondo il post pubblicato dal venditore, l’azienda presenta un fatturato superiore ai 20 milioni di dollari, impiega oltre 250 dipendenti, e protegge la propria infrastruttura con l’antivirus CrowdStrike Falcon, uno dei più noti strumenti EDR in ambito enterprise.

Inoltre, l’infrastruttura tecnica compromessa sarebbe composta da più di 350 host distribuiti su 5 data center, un dato che lascia intuire una realtà aziendale di dimensioni non trascurabili.

L’accesso offerto è di tipo RDP con privilegi di Domain User, il che lo rende potenzialmente utile a gruppi ransomware per movimenti laterali o escalation di privilegi. Il prezzo di partenza dell’asta è 1.000 dollari, con rilanci da 100 e un “Buy Now” a 1.400 dollari.

Non è la prima volta che aziende italiane finiscono nel mirino dei cyber criminali. In passato abbiamo documentato la vendita di accessi simili a realtà dei settori industriale, logistico e sanitario. Tuttavia, l’interesse verso il mondo del retail di fascia alta evidenzia una diversificazione degli obiettivi da parte dei threat actors, forse attratti dal valore dei dati, dalle potenziali frodi finanziarie o dalla capacità di pagare riscatti.

La presenza di una soluzione EDR avanzata come CrowdStrike Falcon non ha impedito la compromissione, il che potrebbe indicare una cattiva configurazione, l’assenza di segmentazione di rete o l’uso di credenziali valide ottenute tramite phishing, infostealer o insider.

Secondo i dati disponibili, l’account chestniybro è attivo dal 2017, ha pubblicato 13 post ed è identificato con il badge “Autogarant 1”, ovvero una vendita andata a buon fine con garanzia del servizio escrow del forum, elemento che potrebbe incentivare l’acquisto da parte di attori ransomware-as-a-service. Degno di nota anche il fatto che, negli ultimi giorni, lo stesso utente ha messo in vendita ben otto accessi analoghi riferiti ad aziende di diversi Paesi, tra cui Stati Uniti e Australia

Questa ennesima vendita di accessi a infrastrutture italiane evidenzia come il mercato dell’inizial access sia ormai una componente chiave dell’ecosistema cyber criminale. Monitorare queste attività, intervenire rapidamente su eventuali segnali di compromissione e rafforzare le difese proattive rimane essenziale per proteggere il tessuto economico nazionale.

L'articolo Preludio al ransomware: In vendita gli accessi a un’azienda italiana del settore retail di gioielli e orologi proviene da il blog della sicurezza informatica.

Negli ultimi due anni ho lavorato principalmente con large language models, occupandomi di training, fine-tuning, prompting e così via, poiché era molto richiesto dal mercato e dagli utenti. Ma credo che gli LLM che lavorano principalmente con il testo siano solo l’inizio della GenAI. A un certo punto, tutti vorranno un’AI fisica, in cui i modelli possano vedere, sentire, percepire e ragionare in modo più concreto e umano.

Quindi iniziamo con la multimodalità. In questo notebook introduco LLaVA, un’architettura in grado di interpretare sia immagini che testo per generare risposte multimodali.

In questo tutorial utilizzeremo componenti più leggeri, adatti a far girare il notebook in un ambiente gratuito come Google Colab.

I componenti che utilizzeremo sono:

1️⃣ CLIP-ViT B/32 come image encoder
2️⃣ TinyLlama-1.1B come language model
3️⃣ Un MLP adapter a 2 layer per collegare i due modelli

Dal paper Visual Instruction Tuning (NeurIPS 2023)

Setup

Prima di inziare a scrivere codice dobbiamo creare il nostro environment.

Installiamo e importiamo le librerie necessarie.

!pip install -U datasets

import json
from pathlib import Path

import requests
import safetensors
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import (
AutoConfig,
AutoTokenizer,
LlamaTokenizer,
LlavaConfig,
LlavaForConditionalGeneration,
LlavaProcessor,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
)
from transformers.models.clip.modeling_clip import CLIPVisionModel
from transformers.models.clip.image_processing_clip import CLIPImageProcessor

Download dei componenti pre-addestrati

Il nostro modello LLaVA sarà composto da :

• Un encoder pre-addestrato CLIP openai/clip-vit-base-patch32

• Un decoder pre-addestrato Tiny LLaMA TinyLlama/TinyLlama-1.1B-Chat-v1.0
• Due layer MLP tra i due che usiamo per il mapping delle dimensioni

vision_backbone_name = "openai/clip-vit-base-patch32"
text_backbone_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

_ = hf_hub_download(
vision_backbone_name, filename="pytorch_model.bin", local_dir="/content"
)
_ = hf_hub_download(
text_backbone_name, filename="model.safetensors", local_dir="/content"
)

Modello

Instanziamo un nuovo modello LLaVA

vision_config = AutoConfig.from_pretrained(vision_backbone_name).vision_config
text_config = AutoConfig.from_pretrained(text_backbone_name)

llava_config = LlavaConfig(vision_config=vision_config, text_config=text_config)

model = LlavaForConditionalGeneration(llava_config).cuda()

model

E’ ora di fare qualche modifica interna al nostro modello

In precedenza abbiamo detto che è possibile costruire un modello LLaVA partendo da un image encoder pre-addestrato e un LLM pre-addestrato. Facciamolo davvero!

Il modello originale di LLaVA è inizializzato a partire da un CLIP-ViT L/14 e un Vicuna v1.5 7B. Per rendere il tutto più gestibile con le risorse offerte dal piano gratuito di Google Colab, utilizzeremo invece un CLIP-ViT B/16 e un TinyLlama 1.1B.

L’unico componente che addestreremo sarà un MLP adapter a 2 layer che collega i due modelli.

def load_weights(path_to_weights: str):
if path_to_weights.endswith(".safetensors"):
return load_safetensors_weights(path_to_weights)
elif path_to_weights.endswith(".bin"):
return load_bin_weights(path_to_weights)
else:
raise ValueError(f"Unsupported weights file: {path_to_weights}")

def load_bin_weights(path_to_weights: str):
return torch.load(path_to_weights, weights_only=True)

def load_safetensors_weights(path_to_weights: str):
return safetensors.torch.load_file(path_to_weights)

vision_backbone_state_dict = load_weights("/content/pytorch_model.bin")
text_backbone_state_dict = load_weights("/content/model.safetensors")

Iniettiamo i pesi del vision backbone nel modello 💉

incompatible_keys = model.vision_tower.load_state_dict(
vision_backbone_state_dict, strict=False
)

assert len(incompatible_keys.missing_keys) == 0, (
f"Missing keys in state dict: {incompatible_keys.missing_keys}"
)

incompatible_keys.unexpected_keys

Iniettiamo i pesi del text backbone nel modello 💉

incompatible_keys = model.language_model.load_state_dict(
text_backbone_state_dict, strict=True
)

Congeliamo i componenti pre-addestrati ❄️

_ = model.vision_tower.requires_grad_(False)
_ = model.language_model.requires_grad_(False)

def count_parameters(model, trainable_only=False):
return sum(
p.numel()
for p in model.parameters()
if not trainable_only or p.requires_grad
)

print(f"Total parameters: {count_parameters(model)}")
print(f"Trainable parameters: {count_parameters(model, trainable_only=True)}")

Processor

tokenizer = LlamaTokenizer.from_pretrained(
text_backbone_name, additional_special_tokens=["", ""]
)
tokenizer.pad_token_id = 32001

Qui sotto è mostrato il formato che useremo per interagire con il nostro modello LLaVA.

La prima parte è il cosiddetto system prompt, che contiene linee guida generali su come il modello dovrebbe rispondere all’utente.

La seconda parte è un Jinja template (fondamentalmente codice) che determina come viene resa la conversazione a partire da un input strutturato (vedi esempio sotto).

LLAVA_CHAT_TEMPLATE = (
"A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. "
"{% for message in messages %}{% if message['role'] == 'user' %}USER: {% else %}ASSISTANT: {% endif %}{% for item in message['content'] %}{% if item['type'] == 'text' %}{{ item['text'] }}{% elif item['type'] == 'image' %}{% endif %}{% endfor %}{% if message['role'] == 'user' %} {% else %}{{eos_token}}{% endif %}{% endfor %}"
)
tokenizer.chat_template = LLAVA_CHAT_TEMPLATE

sample_messages = [
{
"content": [
{
"index": 0,
"text": None,
"type": "image"
},
{
"index": None,
"text": "\nWhat potential activities might be popular at this location?",
"type": "text"
}
],
"role": "user"
},
{
"content": [
{
"index": None,
"text": (
"At this location, with a sandy path leading to the ocean where multiple boats, including "
"sailboats, are moored, popular activities might include boating, sailing, swimming, and "
"beachcombing. Additionally, the sandy path and shoreline provide an ideal setting for leisurely "
"strolls and picnics, while the ocean view offers a serene environment for relaxation and "
"photography. Depending on the specific area and available facilities, other water sports such as "
"kayaking, paddleboarding, and snorkeling could also be prevalent."
),
"type": "text"
}
],
"role": "assistant"
}
]

tokenizer.apply_chat_template(
sample_messages, tokenize=False, add_generation_prompt=False
)

processor = LlavaProcessor(
image_processor=CLIPImageProcessor.from_pretrained(vision_backbone_name),
tokenizer=tokenizer,
patch_size=model.config.vision_config.patch_size,
)
processor.chat_template = LLAVA_CHAT_TEMPLATE

model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)

Dataset

train_dataset = load_dataset(
"HuggingFaceH4/llava-instruct-mix-vsft", split="train", streaming=True
)

Come sono fatti in nostri dati di training?

next(iter(train_dataset))

Come creiamo un batch di esempio?

def get_data_collator(processor, ignore_index):
def collate_examples(examples):
# Extract texts and images from the raw examples
texts =
[] images =
[] for example in examples:
messages = example["messages"]
text = processor.tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=False
)
texts.append(text)
images.append(example["images"][0])

# Process the inputs (tokenize text and transform images)
batch = processor(texts, images, return_tensors="pt", padding=True)

# Create labels
labels = batch["input_ids"].clone()
if processor.tokenizer.pad_token_id is not None:
labels[labels == processor.tokenizer.pad_token_id] = ignore_index
batch["labels"] = labels

return batch

return collate_examples

# NOTE: this does a bit more than a collate function should...

Training

args = Seq2SeqTrainingArguments(
output_dir="/content/training_output",
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
learning_rate=2e-4,
max_steps=350,
lr_scheduler_type="cosine_with_min_lr",
lr_scheduler_kwargs={"min_lr": 2e-5},
warmup_ratio=0.05,
logging_strategy="steps",
logging_steps=5,
fp16=True,
remove_unused_columns=False, # Important!
optim="adamw_torch",
report_to="none",
save_strategy="no", # let's not save the checkpoint to disk, otherwise it'll take 5 mins
)

trainer = Seq2SeqTrainer(
model=model,
args=args,
data_collator=get_data_collator(
processor, ignore_index=model.config.ignore_index,
),
train_dataset=train_dataset,
)

trainer.train()

Inferenza

È importante notare che, per garantire che l’inferenza funzioni come previsto, bisognerebbe utilizzare modelli più pesanti e addestrare per un periodo di tempo più lungo.

Useremo questa immagine per l’inferenza:

conversation = [
{
"content": [
{
"type": "image"
},
{
"text": "\nWhat is represented in the image?",
"type": "text"
}
],
"role": "user"
}
]

image_url = "https://llava-vl.github.io/static/images/monalisa.jpg"

inputs_for_generation = processor(
images=Image.open(requests.get(image_url, stream=True).raw),
text=processor.apply_chat_template(conversation, add_generation_prompt=True),
return_tensors="pt",
)

inputs_for_generation = inputs_for_generation.to(device=model.device)
output = trainer.model.generate(
**inputs_for_generation, max_new_tokens=200, do_sample=False
)

print(processor.decode(output[0], skip_special_tokens=True))

Miglioramenti possibili

• Utilizza un image encoder più grande (es. CLIP-ViT Large) e un LLM più potente (es. Llama 3.1 8B)
• Allena il modello più a lungo. Serve tempo affinché il modello impari a seguire le istruzioni in presenza di image features
• Segui la procedura di addestramento multi-stadio adottata dal LLaVA originale:
  
  • Stage 1: Pre-training for Feature Alignment → addestra il modello su dati di istruzioni a singola interazione, dove viene chiesto di descrivere brevemente l’immagine. Image encoder e LLM sono congelati ❄️
  • Stage 2: Fine-tuning End-to-End → addestra il modello su dati di istruzioni multi-turno. Solo l’image encoder rimane congelato ❄️

  
  

🔗 Demo funzionante: huggingface.co/spaces/badayvedat/LLaVA

Conclusioni

Penso che questo piccolo progetto sia interessante per capire meglio come funzionano i modelli multimodali come LLaVA. Anche se abbiamo utilizzato modelli più piccoli, l’idea principale rimane la stessa: combinare visione e linguaggio in un unico sistema capace di comprendere le immagini e parlarne.

Ovviamente, i risultati ottenuti in questo toy example non sono particolarmente buoni, c’è molto margine di miglioramento. Ma far funzionare LLaVA in un ambiente con risorse limitate è già di per sé una bella sfida.

L'articolo Implementazione di Modelli Multimodali con LLaVA proviene da il blog della sicurezza informatica.

Even if you don’t cast or forge metal yourself, you’re probably aware that you need to get the material very, very hot to make that happen. While some smiths might still stoke coal fires, that’s a minority taste these days; most, like [mikeandmertle] use gas burners to generate the heat. Tired of expensive burners or finicky DIY options [mikeandmertle] built their own Better Burner out of easily-available parts.

Everything you need to make this burner comes from the hardware store: threaded iron pipes of various sizes, hoses and adapters– except for one key piece: a 3D printer nozzle. The nozzle is used here as the all-important gas jet that introduces flammable gas into the burner’s mixing chamber. A demo video below shows it running with a 0.3mm nozzle, which looks like it is putting out some serious heat, but [mikeandmertle] found that could go out if the breather was opened too wide (allowing too much air in the mixture). Eventually he settled on a 0.4mm nozzle, at least for the LPG that is common down under. If one was to try this with propane, their mileage would differ.

That’s the great thing about using printer nozzles, though: with a tapped M6 hole on the cap of the gas pipe serving as intake, one can quickly and easily swap jets without worrying about re-boring. Printer nozzles are machined to reasonable accuracy and you can get a variety pack with all available sizes (including ones so small you’re probably better off using resin) very cheaply.

These sorts of use-what-you-have-on-hand hacks seem to be [mikeandmertle]’s specialty– we’ve seen their PVC thumb nut and their very simple mostly-wooden wood lathe here before.

youtube.com/embed/SpwoR4yHE8U?…

hackaday.com/2025/06/18/gas-bu…

Due gravi vulnerabilità di sicurezza sono state individuate nei dispositivi NetScaler ADC e NetScaler Gateway (precedentemente noti come Citrix ADC e Gateway). Queste falle possono permettere a un attaccante di accedere a dati sensibili e compromettere l’infrastruttura di rete aziendale.

Il Cloud Software Group, sviluppatore di queste soluzioni, ha diffuso un avviso urgente invitando tutti i clienti ad aggiornare immediatamente i dispositivi interessati. Le vulnerabilità, catalogate come CVE-2025-5349 e CVE-2025-5777, hanno ricevuto punteggi CVSS di 8,7 e 9,3, indicando un livello di rischio critico.

Le vulnerabilità sono state scoperte tramite divulgazione responsabile da parte dei ricercatori di sicurezza di Positive Technologies e ITA MOD CERT (CERTDIFESA), che hanno collaborato con Cloud Software Group per proteggere i clienti prima della divulgazione al pubblico.

Cloud Software Group raccomanda vivamente ai clienti interessati di installare immediatamente le versioni aggiornate. L’azienda ha rilasciato versioni patchate, tra cui NetScaler ADC e Gateway 14.1-43.56, la versione 13.1-58.32 e i relativi aggiornamenti conformi allo standard FIPS.

Le falle di sicurezza interessano numerose versioni dei prodotti NetScaler attualmente in uso presso organizzazioni in tutto il mondo. Tra i sistemi vulnerabili figurano le versioni 14.1 (precedente alla 14.1-43.56) di NetScaler ADC e Gateway, la versione 13.1 (precedente alla 13.1-58.32) e diverse versioni conformi allo standard FIPS.

Particolarmente preoccupante è il fatto che le versioni 12.1 e 13.0 di NetScaler, ora designate come End of Life (EOL), rimangano vulnerabili e non siano disponibili patch di sicurezza. Anche le organizzazioni che utilizzano Secure Private Access in distribuzioni on-premise o ibride con istanze NetScaler sono a rischio e devono aggiornare immediatamente i propri sistemi.

Dopo il processo di aggiornamento, gli amministratori devono eseguire comandi specifici per terminare tutte le sessioni ICA e PCoIP attive su tutte le appliance NetScaler in coppie o cluster ad alta disponibilità. Ciò garantisce una protezione completa contro potenziali tentativi di exploit.

Le organizzazioni che utilizzano l’infrastruttura NetScaler dovrebbero dare priorità a questi aggiornamenti, data la natura critica di queste vulnerabilità e il loro potenziale di consentire l’accesso non autorizzato a dati aziendali sensibili e risorse di rete.

L'articolo Allarme NetScaler ADC e Gateway: Due bug gravi mettono a rischio le aziende in tutto il mondo proviene da il blog della sicurezza informatica.

There’s a famous old story about [Charles Steinmetz] fixing a generator for [Henry Ford]. He charged a lot of money for putting a chalk X in the spot that needed repair. When [Ford] asked for an itemization, the bill read $1 for the chalk, and the balance for knowing where to draw the X. With today’s PCB layout tools, it seems easy to put components down on a board. But, as [Kasyan TV] points out in the video below, you still have to know where to put them.

The subject components are inductors, which are particularly picky about placement, especially if you have multiple inductors. After all, inductors affect one another — that’s how transformers work. So there are definite rules about good and bad ways to put a few inductors on a board.

However, in the video, air-core coils go through several orientations to see which configuration has the most and least interference. Using a ferrite core showed similar results. The final examples use toroids and shielded inductors.

One reason ferrite toroids are popular in radio designs is that coils made this way are largely self-shielding. This makes placement easier and means you don’t need metal “cans” to shield the inductors. How much do they shield? The orientation makes a little difference, but not by much. It is more important to give them a little space between the coils. Shields work, too, but note that they also change the inductance value.

While we like the idea of grabbing a breadboard and a scope to measure things, we want to point out that you can also simulate. If you didn’t understand the title, you probably don’t listen to Propellerheads.

youtube.com/embed/VhruG2Hu7iY?…

hackaday.com/2025/06/18/a-numb…

This week Jonathan chats with Geekwife! What does a normal user really think of Linux on the desktop and Open Source options? And what is it really like, putting up with Jonathan’s shenanigans? Watch to find out!

youtube.com/embed/2sPOsnGacAE?…

Did you know you can watch the live recording of the show right on our YouTube Channel? Have someone you’d like us to interview? Let us know, or contact the guest and have them contact us! Take a look at the schedule here.

play.libsyn.com/embed/episode/…

Direct Download in DRM-free MP3.

If you’d rather read along, here’s the transcript for this week’s episode.

Places to follow the FLOSS Weekly Podcast:

• Spotify
• RSS

Theme music: “Newer Wave” Kevin MacLeod (incompetech.com)

Licensed under Creative Commons: By Attribution 4.0 License

hackaday.com/2025/06/18/floss-…

You might think that a nuclear explosion is not something you need a detector for, but clearly not everyone agrees. [Bigcrimping] has not only built one, the BhangmeterV2, but he has its output publicly posted at hasanukegoneoff.com, in case you can’t go through your day without checking if someone has nuked Wiltshire.

The Bhangmeter is based on an off-the-shelf “nuclear event detector”, the HSN-1000L by Power Device Corporation.
The HSN 1000 Nuclear Event Detector at the heart of the build. We didn’t know this thing existed, never mind that it was still available.
Interfacing to the HSN-1000L is very easy: you give it power, and it gives you a pin that stays HIGH unless it detects the characteristic gamma ray pulse of a nuclear event. The gamma ray pulse occurs at the beginning of a “nuclear event” precedes the EMP by some microseconds, and the blast wave by perhaps many seconds, so the HSN-1000 series seems be aimed at triggering an automatic shutdown that might help preserve electronics in the event of a nuclear exchange.

[Bigcrimping] has wired the HSN-1000L to a Raspberry Pi Pico 2 W to create the BhangmeterV2. In the event of a nuclear explosion, it will log the time the nuclear event detector’s pin goes low, and the JSON log is pushed to the cloud, hopefully to a remote server that won’t be vaporized or bricked-by-EMP along with the BhangmeterV2. Since it is only detecting the gamma ray pulse, the BhangmeterV2 is only sensitive to nuclear events within line-of-sight, which is really not where you want to be relative to a nuclear event. Perhaps V3 will include other detection methods– maybe even a 3D-printed neutrino detector?

If you survive the blast this project is designed to detect, you might need a radiation detector to deal with the fallout. For identifying exactly what radionuclide contamination is present, you might want a gamma-ray spectrometer.

It’s a sad comment on the modern world that this hack feels both cold-war vintage and relevant again today. Thanks to [Tom] for the tip; if you have any projects you want to share, we’d love to hear from you whether they’d help us survive nuclear war or not.

hackaday.com/2025/06/18/bhangm…

Il 2 giugno 2025, l’Institute for the Study of War (ISW) ha pubblicato un’analisi secondo cui Russia e Ucraina si trovano impegnate in una competizione strategica per sviluppare droni dotati di intelligenza artificiale (IA) e apprendimento automatico (machine learning), con l’obiettivo di ridurre la dipendenza dagli operatori umani, superare i limiti del riconoscimento visivo tradizionale e contrastare l’interferenza delle contromisure elettroniche.

Entrambi i Paesi stanno cercando di integrare tali tecnologie in nuovi modelli, puntando a una progressiva automazione delle operazioni. Tuttavia, nessuna delle due nazioni ha ancora implementato questi sistemi su vasta scala nei teatri di guerra.

Dal 2023, la Russia ha aumentato gli sforzi per dotare i suoi droni di capacità di visione artificiale. Il drone “Tyuvik“, ad esempio, rappresenta uno dei primi tentativi russi di produrre un velivolo leggero d’attacco con guida autonoma basata sul riconoscimento visivo.

Equipaggiato con moduli NVIDIA Jetson, telecamere ad alta risoluzione e dischi rigidi ad alta capacità, il Tyuvik è in grado di identificare e colpire bersagli senza intervento umano. Il 18 maggio 2025, un esperto ucraino ha osservato l’impiego di sciami di sei droni russi in configurazione autonoma, rivelando un salto di qualità significativo nell’applicazione della tecnologia IA sul campo.
Drone da attacco leggero Tuvik
Anche l’Ucraina ha intrapreso con determinazione la strada della dronistica intelligente. Già nel 2024, il Ministro della Trasformazione Digitale Fedorov annunciava il progetto di un drone con capacità simili al russo Lancet-3. Un anno dopo, il drone “Gogol-M“, sviluppato da una startup ucraina, ha completato con successo la sua prima missione autonoma. Questo drone-madre è in grado di trasportare e rilasciare due droni FPV, con attacchi a una distanza di oltre 300 km, dimostrando un’elevata capacità operativa. Tuttavia, come nel caso russo, anche le soluzioni ucraine sono ancora in fase di test operativo e non rappresentano un asset consolidato.

Entrambe le parti devono affrontare ostacoli significativi nello sviluppo e nell’uso operativo di droni IA. Malfunzionamenti nei sistemi di aggancio automatico, limiti nella visione artificiale, problemi di riconoscimento a lunga distanza e incapacità di seguire bersagli in movimento sono difficoltà comuni. A ciò si aggiunge la crescente efficacia delle contromisure elettroniche.
Aeromobili senza pilota dotati di FPV
Dal punto di vista organizzativo, la Russia sta cercando di colmare il divario attraverso la creazione di un ecosistema digitale militare. Il progetto “Russian Digital Sky“, sostenuto da GLONASS e dalla National Technology Initiative, mira a costruire una rete satellitare e un’infrastruttura cloud capace di raccogliere, processare e utilizzare i dati provenienti dal campo di battaglia in tempo reale. L’obiettivo è fornire ai droni una consapevolezza situazionale autonoma, simile a quella umana, per distinguere amici, nemici e obiettivi strategici, potenziando ulteriormente le capacità decisionali delle unità autonome.

In sintesi, la corsa tra Russia e Ucraina per il dominio dei cieli attraverso droni autonomi rappresenta una nuova fase della guerra tecnologica. Le implicazioni sono enormi: se queste tecnologie dovessero maturare, potrebbero cambiare radicalmente il modo in cui si combattono i conflitti, riducendo il tempo di reazione, aumentando la letalità e ridefinendo le regole dell’ingaggio. Tuttavia, al momento, sia Mosca che Kiev si trovano ancora in una fase embrionale, dove ogni avanzamento tecnologico è accompagnato da sfide operative e morali ancora tutte da risolvere.

L'articolo La corsa ai droni autonomi e la sfida tecnologica tra Russia e Ucraina proviene da il blog della sicurezza informatica.

La Cina è diventata il secondo Paese al mondo ad avviare la sperimentazione clinica di un’interfaccia cervello-computer invasiva sugli esseri umani. Secondo CCTV, l’impianto è stato eseguito su un uomo di 37 anni che ha perso tutti gli arti a causa di una scossa elettrica ad alto voltaggio più di dieci anni fa. Ora, per la prima volta dopo molti anni, può di nuovo interagire con il mondo esterno, non con le mani, ma direttamente, con i pensieri.

A marzo di quest’anno, i ricercatori hanno impiantato nel cervello del paziente un dispositivo delle dimensioni di una moneta e i sottilissimi elettrodi che costituiscono un’interfaccia neurale. Poche settimane dopo l’operazione, il paziente ha imparato a controllare un cursore su uno schermo, a giocare ai videogiochi, ad avviare applicazioni e persino a giocare a scacchi, con una precisione prossima a quella di un utente normale. Tutte le azioni vengono eseguite esclusivamente tramite l’attività neurale.

Il lavoro è coordinato dal Centro di Eccellenza per le Neuroscienze e le Tecnologie Intelligenti dell’Accademia Cinese delle Scienze (CAS), dall’Ospedale Huashan dell’Università Fudan di Shanghai e da partner industriali. In precedenza, solo il progetto Neuralink di Elon Musk aveva dimostrato una svolta simile.

Tuttavia, per un aspetto, lo sviluppo cinese ha superato i suoi concorrenti: secondo il professor Zhao Zhengtao del CAS, il neuroelettrodo inserito nel cervello del paziente è diventato il più flessibile e miniaturizzato al mondo. Il suo diametro è pari a solo 1/100 della larghezza di un capello umano, cinque volte inferiore a quello dell’analogo americano. Il sensore può quindi piegarsi liberamente senza danneggiare i tessuti o causare infiammazioni.

Ogni elettrodo contiene 32 sensori che registrano i segnali neurologici. L’intero sistema percepisce gli impulsi elettrici microscopici che si verificano quando determinate aree del cervello sono attive e trasmette istantaneamente i dati al dispositivo, che li interpreta in comandi.

L’intero impianto misura 26 millimetri di diametro e meno di 6 millimetri di spessore. A titolo di paragone, il dispositivo Neuralink ha uno spessore quasi doppio. Per installare l’impianto, i neurochirurghi hanno prima assottigliato una sezione del cranio appena sopra la corteccia motoria, l’area che controlla il movimento. Un elettrodo flessibile è stato quindi inserito nella finestra di 5 millimetri di diametro risultante.

Naturalmente, prima dell’intervento, l’équipe ha eseguito una serie di scansioni per costruire un modello 3D accurato del cervello del paziente. Durante la procedura, è stato utilizzato un sistema di navigazione in tempo reale per garantire un posizionamento preciso al millimetro. L’intero processo ha richiesto meno di mezz’ora.

Ma la precisione chirurgica è solo l’inizio. Nei prossimi mesi, il paziente sarà sottoposto a un programma di adattamento. I ricercatori gli insegneranno a controllare le protesi robotiche: prima semplici movimenti delle mani, poi lavorare con oggetti nello spazio fisico. La fase successiva sarà la padronanza di dispositivi complessi: robot autonomi, cani meccanici e altri agenti di intelligenza artificiale “incarnati” a cui è possibile impartire comandi direttamente dalle profondità della coscienza.

È importante notare che lo sviluppo è stato sottoposto a test preliminari su roditori e macachi. Solo in seguito è stato considerato pronto per l’uso sugli esseri umani. Nel 2024 sono previsti diversi altri interventi su piccola scala su persone affette da paralisi e SLA. Entro il 2026, il team prevede di estendere il campione a 40 pazienti.

Secondo Zhao, il tessuto nervoso è praticamente inconsapevole della presenza di qualcosa di estraneo, il che riduce drasticamente il rischio di rigetto e consente una funzionalità a lungo termine senza dover ricorrere a interventi chirurgici ripetuti. Considerando che la maggior parte degli impianti invasivi moderni presenta reazioni immunitarie dopo pochi mesi, questa proprietà rappresenta un vantaggio fondamentale.

Gli obiettivi a lungo termine del team vanno ben oltre le semplici capacità motorie. Gli scienziati stanno già sviluppando protocolli che consentirebbero l’ utilizzo di tali interfacce per trattare ictus e morbo di Alzheimer, ripristinare l’attività motoria in individui con gravi lesioni spinali e, potenzialmente, persino ripristinare parzialmente la vista nei non vedenti.

Tuttavia, sullo sfondo della continua rivalità tecnologica tra Stati Uniti e Cina, questo sviluppo è anche una dichiarazione di grande ambizione. Allo stesso tempo, la Cina non si concentra sull’integrazione industriale, come Elon Musk, ma sull’efficacia clinica e sulla miniaturizzazione.

L'articolo BCI (Brain Computer Interface). La Cina supera Neuralink in precisione e miniaturizzazione proviene da il blog della sicurezza informatica.

When [daniely101] wanted a split keyboard, he decided to build his own. It wound up costing $25 to create a wireless board with no custom PCB required. Each half has its own microcontroller, and the whole thing connects via Bluetooth. While we don’t mind making a PCB, we can appreciate that you could change your mind easily with this wiring scheme.

The 3D printed case holds the keys, and then it is just a matter of carefully soldering the keys to the microcontrollers. Of course, each side also has to have its own battery. The ZMK firmware is split in half, one part for each side of the keyboard. The nRF52840 CPUs have plenty of wireless connectivity. The keys are set in rows and columns, so the amount of soldering back to the controller is manageable.

While we applaud the wireless design, it does seem odd that you have to charge both halves and turn them on and off separately. But that’s the nice thing about a design like this — you could modify the design to not have a split. Or, you could allow one flexible wire pair to run across for power. Of course, you could modify the layout, including adding or deleting keys.

You might consider adding a pointing device. At least you don’t have to pull out a saw.

youtube.com/embed/VS1WQ7kv4qA?…

hackaday.com/2025/06/18/split-…

One of the most frustrating things to me is looking at a freshly-flashed and just powered up single board computer. My goal with them is always getting to a shell – installing packages, driving GPIOs, testing my proof of concept code, adjusting the device tree to load peripheral drivers. Before I can do any of that, I need shell access, and getting there can be a real hassle.

Time after time, I’ve struggled trying to get to a shell on an SBC. For best results, you’d want to get yourself a keyboard, monitor, and an Ethernet cable. Don’t have those, or there’s no space to place them? Maybe a UART connection will work for you – unless it’s broken or misconfigured. Check your pinouts twice. Sure, nowadays you can put WiFi credentials into a text file in /boot/ – but good luck figuring out the IP address, or debugging any mistakes you might make formatting the file. Nowadays, Pi 4 and 5 expose a USB gadget connection on the USB-C port, and that helps… unless you’re already powering the Pi from that port. There’s really no shortage of failure modes here.

If you put a Pi on your network and it goes offline, you generally just don’t know what happened unless you reboot it, which can make debugging into a living hell. I’ve dealt with single-board computers mounted above fiberglass lifted ceilings, fleets of Pi boards at workshops I organized, pocket-carried Pi boards, and at some point, I got tired of it all. A hacker-aimed computer is meant to be accessible, not painful.

Server-Grade Interfaces For All

That’s why, for years now, I’ve been working on a cheap and accessible embedded UI, called ZPUI (Zippy UI) – with its help, a cheap I2C screen and a few buttons is all it takes to keep track of your Pi or other Linux device.

A separate lightweight control interface isn’t a new concept. Back in the glorious era of character LCDs and non-standard mounting boxy cute servers, you could get a 16×2 display and five arrow keys on a Sun machine, and with help of a little bespoke software, you could do basic management actions on your server without having to break out a KVM.

One of my first semi-serious projects, way back in 2014, was a HD44780 library for Raspberry Pi use, universal and lightweight, supporting both direct GPIO access and I2C backpacks with ease. People have had used those for IP address display for a while by then, but it wasn’t enough for me. I wanted to easily power off my boards to avoid SD card corruption (which was way worse back in the day), figure out my boards’ IP addresses without Nmap scans, and connect to WiFi networks without SD card machinations. All throughout, it felt like a piece of software someone should’ve had written years ago. It’s a simple concept – if I have physical access to my SBC, I should be able to take control of it.

So, with a HD44780, a USB numpad, and a heap of Python code, I’ve built the first version of the software I called pyLCI – for Linux Control Interface. I gave it app loading support, then wrote code to parse commands like ip addr, wpa_cli for WiFi connection management, tvservice for HDMI monitor connection debug, reboot and poweroff, as well as an ability to run arbitrary pre-defined scripts from a menu. I made sure it’d only require 5 buttons at all times – up, down, left, right, and enter, and that it’d work with character LCDs from as small as 16×2 to as big as 20×4.

pyLCI quickly became a useful tool in my SBC forays, and I’ve built it into a number of my portable devices, most of them Pi-powered. I’ve added it to a portable hardware hacking workbench I built for SPI flash and general hardware tinkering, home automation Pi boards I’d run, and even a desktop/pocket Pi 2 that served as only computer for almost half a year. When I ran Raspberry Pi workshops in our hackerspace, I bought a few character-LCD-and-button HATs and used them to determine IP addresses of student-issued Pi boards, so that I wouldn’t need to drag a monitor around or do USB-UART interventions.

Entering WiFi passwords with arrow keys wasn’t ideal, but it was miles ahead of the frustration I used to routinely experience before it, every time I brought a Pi somewhere for a project – only to get effectively locked out of a computer I own.

Bigger Screens, Bigger Ambitions

When I worked on ZeroPhone, an open-source Raspberry Pi Zero-based numpad phone, naturally, I forked pyLCI into a base for the UI, called it ZPUI (for ZeroPhone UI), and decided to target the super common 128×64 screens. Initially, I made the color screen imitate a character screen – it worked kind of well as a stopgap but resulted in tiny text. It took a good while to make the screen readable, make apps work passably well and write new better-working ones, implement numpad input in addition to arrow keys input, and I’ve ended up learning a ton from building an UI framework where none was intended to be.

Recently, I’ve reignited my portable platform building ambitions, and as part of a hacker collective, I’ve been working on a Beepy derivative device – a QWERTY PDA-like Pi Zero-based pocket Linux terminal. Just like many portable Linux devices in this form-factor, it’s badly missing a low-frills graphical UI, with three or four people having attempted to write one, and one in particular getting pretty far. I ported ZPUI to a larger screen, borrowed a UI layout mockup from one of the more successful Beepy UI projects, and I’m now porting ZPUI to larger screens. My goal with ZPUI is making your Linux devices accessible and friendly, and the Beepy community could definitely benefit from a software boost like that.

My goal is creating a UI that you can use to make any of your Linux devices accessible – no matter if you’re building a home automation panel with a Pi at its heart, or an OpenWRT-powered pocket router, putting together an overpowered Meshtastic node you want to adjust on the fly, or a PWN4Pi device that you want to manually pick RubberDucky scripts for, designing failsafes for a robot with computer vision, or simply organizing workshops where seeing your Pi’s IP address is important, in circumstances of twenty students who all want your attention during setup. This year, I’ve started working on ZPUI again, bringing it up to speed with modern software realities, and I invite you to try it out in your projects.

How ZPUI Can Help You

Cheap enough to order a dozen, for $5, only needs an OLED and buttons, and it’s very JLC-compatible
At minimum, you only need a small 128×64 OLED screen and give buttons – for instance, if you have a Waveshare Pi Zero hat, it will do just fine. In case you’re ordering PCBs anytime soon, I’ve also designed a businesscard form-factor Pi shield, which fits on any Pi and even works over QWIIC if you want – throw the board into your next JLC order, solder an OLED and a few jellybean buttons to it, follow the install instructions, and enjoy the extra point of control over your Linux install.

As-is, ZPUI can do most of the basic tasks for you – show network info, connect to WiFi networks (and even display known network passwords), manage system services with help of a systemctl API, poweroff/reboot, unmount partitions so you don’t have to SSH in to unplug that one flash drive, list USB devices so you know if your favourite device fell off the bus, and do a number of other things (there’s even an AVRDUDE app!). It will even let you input console commands through arrow keys in a pinch.
Example ZPUI apps, complete with instructions, coming soon!
Currently, apart from UI improvements, I’m working on a heap of mechanisms to make third-party app designs easier. You already can develop ZPUI apps, and you can even distribute ZPUI apps as Python packages, but there’s still work to do. If you want to help contribute and tackle goals like, say, a raspi-config app or a Bluetooth config interface, you’re most welcome to join in and help – there’s even a ZPUI emulator for app development purposes!

ZPUI is a project aimed to make your other projects easier. I invite you to try it out, especially if you’ve faced the kind of problems I’ve told about in the article intro. If it were up to me, SBCs like Raspberry Pi would come with these kinds of interfaces out of the box, simply because of the insanely large amount of problems I’ve had it solve and figure out.

Unexpectedly Cyberpunk

Here’s a cool demo! I’ve assembled a ZPUI businesscard into a palm-sized shield, with a QWIIC cable connected to it. On my SBCs, I have QWIIC sockets exposed, with ZPUI installed and configured to expect such a shield. When I plug it in, ZPUI detects it on the I2C bus and shows up on the screen. This palm-sized shield feels surprisingly cyberpunk to use, akin to having a cable in your wrist that lets you tap into any device of your choice. For a while now, all my devices come with QWIIC connectors, because of just how much ZPUI helps me in bringup and development.

If you have any questions, ask away, and I hope ZPUI can help you. If not – let me know! This year, I’m aiming to seriously upgrade it, building it into a fully-featured UI it is meant to be, and if there’s a feature you’re looking for, it could very well get implemented alongside.

The original ESP32 may be a little long in the tooth by now, but it remains a potent tool for connected devices. We were drawn to [Max Pflaum]’s ESP32 Dashboard as a great example, it’s an ESP32 hooked up to an e-paper display. The hardware is simple enough, but the software is what makes it interesting.

This is deigned as a configurable notification tool, so to make it bend to the user’s will a series of widgets can be loaded onto it. The device runs MicroPython, making it easy enough to write more than the ones already on place. The screen is divided into four zones, allowing for a range of widgets to be used at once. All the details can be found in a GitHub repository.

We like it for its configurability and ease of programming, and because it delivers well on the promise of a useful device. An ESP32 and e-ink combination with MicroPython apps is something we’ve seen before in the world of badges.

hackaday.com/2025/06/18/esp32-…

I ran into an old episode of Hogan’s Heroes the other day that stuck me as odd. It didn’t have a laugh track. Ironically, the show was one where two pilots were shown, one with and one without a laugh track. The resulting data ensured future shows would have fake laughter. This wasn’t the pilot, though, so I think it was just an error on the part of the streaming service.

However, it was very odd. Many of the jokes didn’t come off as funny without the laugh track. Many of them came off as cruel. That got me to thinking about how they had to put laughter in these shows to begin with. I had my suspicions, but was I way off!

Well, to be honest, my suspicions were well-founded if you go back far enough. Bing Crosby was tired of running two live broadcasts, one for each coast, so he invested in tape recording, using German recorders Jack Mullin had brought back after World War II. Apparently, one week, Crosby’s guest was a comic named Bob Burns. He told some off-color stories, and the audience was howling. Of course, none of that would make it on the air in those days. But they saved the recording.

A few weeks later, either a bit of the show wasn’t as funny or the audience was in a bad mood. So they spliced in some of the laughs from the Burns performance. You could guess that would happen, and that’s the apparent birth of the laugh track. But that method didn’t last long before someone — Charley Douglass — came up with something better.

Sweetening

The problem with a studio audience is that they might not laugh at the right times. Or at all. Or they might laugh too much, too loudly, or too long. Charley Douglass developed techniques for sweetening an audio track — adding laughter, or desweetening by muting or cutting live laughter. At first, this was laborious, but Douglass had a plan.

He built a prototype machine that was a 28-inch wooden wheel with tape glued to its perimeter. The tape had laughter recordings and a mechanical detent system to control how much it played back.

Douglass decided to leave CBS, but the prototype belonged to them. However, the machine didn’t last very long without his attention. In 1953, he built his own derivative version and populated it with laughter from the Red Skelton Show, where Red did pantomime, and, thus, there was no audio but the laughter and applause.

Do You Really Need It?

There is a lot of debate regarding fake laughter. On the one hand, it does seem to help. On the other hand, shouldn’t people just — you know — laugh when something’s funny?

There was concern, for example, that the Munsters would be scary without a laugh track. Like I mentioned earlier, some of the gags on Hogan’s Heroes are fine with laughter, but seem mean-spirited without.

Consider the Big Bang theory. If you watch a clip (below) with no laugh track, you’ll notice two things. First, it does seem a bit mean (as a commenter said: “…like a bunch of people who really hate each other…” The other thing you’ll notice is that they pause for the laugh track insertion, which, when there is no laughter, comes off as really weird.

youtube.com/embed/jKS3MGriZcs?…

Laugh Monopoly

Laugh tracks became very common with most single-camera shows. These were hard to do in front of an audience because they weren’t filmed in sequence. Even so, some directors didn’t approve of “mechanical tricks” and refused to use fake laughter.

Even multiple-camera shows would sometimes want to augment a weak audience reaction or even just replace laughter to make editing less noticeable. Soon, producers realized that they could do away with the audience and just use canned laughter. Douglass was essentially the only game in town, at least in the United States.

The Douglass device was used on all the shows from the 1950s through the 1970s. Andy Griffith? Yep. Betwitched? Sure. The Brady Bunch? Of course. Even the Munster had Douglass or one of his family members creating their laugh tracks.

One reason he stayed a monopoly is that he was extremely secretive about how he did his work. In 1960, he formed Northridge Electronics out of a garage. When called upon, he’d wheel his invention into a studio’s editing room and add laughs for them. No one was allowed to watch.

You can see the original “laff box” in the videos below.

youtube.com/embed/tpY0Muy_1qI?…

youtube.com/embed/yCUCBkVG-Dw?…

The device was securely locked, but inside, we now know that the machine had 32 tape loops, each with ten laugh tracks. Typewriter-like keys allowed you to select various laughs and control their duration and intensity,

In the background, there was always a titter track of people mildly laughing that could be made more or less prominent. There were also some other sound effects like clapping or people moving in seats.

Building a laugh track involved mixing samples from different tracks and modulating their amplitude. You can imagine it was like playing a musical instrument that emits laughter.

Before you tell us, yes, there seems to be some kind of modern interface board on the top in the second video. No, we don’t know what it is for, but we’re sure it isn’t part of the original machine.

The original laff box wound up appearing on Antiques Roadshow where someone had bought it at a storage locker auction.

End of an Era

Of course, all things end. As technology got better and tastes changed, some companies — notably animation companies — made their own laugh tracks. One of Douglass’ protégés started a company, Sound One, that used better technology to create laughter, including stereo recordings and cassette tapes.

Today, laugh tracks are not everywhere, but you can still find them and, of course, they are prevalent in reruns. The next time you hear one, you’ll know the history behind that giggle.

If you want to build a more modern version of the laff box, [smogdog] has just the video for you, below.

youtube.com/embed/hsSoumV7Ucw?…

hackaday.com/2025/06/18/just-f…