Pinned Tweet
Zafena ICT has released #DirectBT an API to talk to #Bluetooth #BLE chip directly using the HCI L2CAP API. A continuation of Intel's TinyB for C++ and Java project with focus on embedded #Linux. DirectBT allow BT use without the bluez bluetoothd. ict.zafena.se/cgit/direct_bt…
Xerxes Rånby retweeted
update your boxes /now/
the default user on alpine's aws and azure images take any password longer than 256 characters.
yes, any password. yes. i know. yes.
*sshole is out
if you run sshd on alpine, openwrt or any musl box with password auth on: update now
official writeup: sshhole.com
Xerxes Rånby retweeted
I never believed Claude Code could delete a repo.
Until it deleted mine. 1+ year of work on Solidity → code property graphs. The .git, every commit, every branch, gone in one command.
No prompt. Top model.
Here's the bug. It's one missing pair of quotes. 🧵
Xerxes Rånby retweeted
Holy sh*t. Claude Code just found a hidden chip inside my Chinese power bank from Guangzhou. Every time I charged my iPhone, it quietly copied the whole phone…
It also read our saved Wi-Fi password off my iPhone, got onto our home network and sent everything to a server.
I bought it for $19 at an airport kiosk there 3 weeks ago. No brand, 30,000 mAh on the label, and it felt heavy.
The first time I plugged in, the screen asked "Trust This Computer?". I tapped Trust without thinking and went on with my day. That one tap gave it access to everything.
This morning I finally set up Claude Code to warn me when any device starts reading my files. An hour later, 10 seconds into charging, the screen filled with yellow warnings, then red ones: data was moving when it should only be charging.
I asked Claude Code what was going on. My phone saw the power bank as a small computer with 64 GB of storage and its own internet connection.
A USB cable has wires for power and wires for data, and a normal charger only uses the power ones. This one used both, and it had already copied all of this:
→ /device → IMEI and serial number
→ /contacts → 1,206 numbers
→ /apps → every app I have, including my 2 bank apps
→ /photos → 3,912 pictures, my passport among them
→ /wifi → our network name and its key
→ /wife's iPhone → her photos too, she charged from it twice and tapped Trust too
Each time we plugged in, it used that key to get online and send out the new files:
sends to → 47.***.***.12
uploads → 19 in 3 weeks
last one → last night at 2:14, while we slept
I pulled the cable right away. Then Claude Code blocked that address on our router and walked me through changing the Wi-Fi password and the logins for my bank apps.
I had it opened at a repair shop, and what was inside is in the first comment. A 30-second check for your own is in the second one. Save this and test every power bank in your house today.
Xerxes Rånby retweeted
1/ CVE-2026-98432, the remote Linux TCP bug: I reproduced it after just a few hours with a local LLM 🤯.
Here's the plain-English version of the bug & how it works ⬇️
(Obv. not sharing the exact exploit, but it's trivial to make)
Xerxes Rånby retweeted
När jag arbetar med akademiker älskar jag att vi journalister INTE HÅLLER PÅ OCH FORMATERAR TEXT I WORD-DOKUMENT. Vad ni älskar era olika fonter, fäger, och storlekar?! Vad är det för fel på ren text? Hardcore-redaktörer använder inte word alls, utan bara rätt in i mailet.
Xerxes Rånby retweeted
I replicated this with Claude Code!
It took a live webcam 7 km south of Southampton, UK and predicted its location purely from doppler effect in audio spectrogram + open-source aircraft location data.
Lo and behold, the predicted location (heatmap) peaks at actual location where webcam is situated.
It's crazy that this works at all, and crazier still I replicated it within a few hours.
Xerxes Rånby retweeted
A supercomputer simulation of the heart of a supermassive black hole reveals how its immense gravity deflects light from accretion flows when viewed from different perspectives 🔭
Xerxes Rånby retweeted
i've reproduced the results from the MIT blog post today on weight-space programming. but one additional result i have to add: this is a new, step-change emerging capability that's appeared in just the latest set of models.
Xerxes Rånby retweeted
We asked GPT-6 Astra to edit Qwen3.5-0.8B weights to improve math.
It directly changed only 0.016% of weights, fixing 0.8B's reasoning loops & improving math up to 6x and even instruction following 3x, without gradients or training.
We call this Weight-Space Programming: frontier LLMs can now natively read/write neural network weights! 🧵
Blog: rikiyat.github.io/blog/weigh…
Readers added context they thought people might want to know
LLM was given weights explicitly as text in prompt and used code/forward passes (per authors' logs) to ablate Qwen looping direction, a known thinking-mode issue per model card. Primarily fixed repetition in that mode, not general 'natively' improving weights/math.
rikiyat.github.io/blog/weight-sp…
github.com/RikiyaT/lm_und…
huggingface.co/Qwen/Qwen3.5-0…
huggingface.co/RikiyaT/Qwen3.…
Xerxes Rånby retweeted
Qwen3.8-27B reportedly shrank from 55.6GB to just 5.9GB while retaining 98.2% of its aggregate benchmark performance.
That’s an approximately 89.4% reduction in model size, according to PrismML, the team behind Bonsai.
Here are the reported numbers:
Original Qwen3.8-27B: 55.6GB
Bonsai 2 compressed version: 5.9GB
Aggregate benchmark performance retained: 98.2%
Previous Bonsai 27B version: approximately 95% retention
Evaluation coverage: 20 benchmarks
The compression technology behind this is ternary quantization.
Traditional model weights use numerical values represented at different levels of precision. Ternary quantization takes a much more aggressive approach, representing weights using three possible values, typically -1, 0 and +1, alongside scaling factors.
This drastically reduces the number of bits needed to store the model.
But shrinking weights is only half the challenge. The real difficulty is preserving the information they contain.
Push quantization too far and the model can lose important distinctions that affect reasoning, coding, instruction following and other tasks.
Bonsai 2 reportedly improves on the previous version in areas such as:
Coding agents
Multimodal reasoning
Long-horizon tool use
The agentic capabilities are particularly interesting.
An AI coding agent might need to inspect an entire codebase, understand dependencies, edit several files, execute tests, interpret errors and repeat the process until the task is complete.
Maintaining those abilities after such aggressive compression is more significant than simply preserving performance on short question-and-answer benchmarks.
Why this matters for local AI
A 5.9GB model is much easier to distribute and store than a 55.6GB version.
It could make larger models more accessible to people running local inference on consumer GPUs, laptops and other memory-constrained systems.
There is an important distinction, though: 5.9GB is the reported model size, not the total memory required to run it. Runtime memory also depends on the KV cache, context length, activations and inference-engine overhead.
The 98.2% figure also represents aggregate performance across 20 benchmarks. It doesn’t mean the compressed model performs identically on every task. Some capabilities may retain more accuracy than others, which is why independent evaluations matter.
Still, moving from approximately 95% retention in the previous Bonsai version to 98.2% with Bonsai 2 is a notable reported improvement.
If independent testing confirms these results, this could make models that previously required substantial hardware much more practical to run locally.
The real test for compression is not how small the model becomes. It’s how much of its useful capability survives the reduction.
Qwen3.8-35B-A3B is reportedly generating around 50 tokens/s on an RTX 3060 with just 12GB VRAM and 16GB system RAM.
The same setup reportedly delivers around 550 tokens/s in prompt processing.
Here’s the configuration:
GPU: RTX 3060, 12GB VRAM
System RAM: 16GB
Quantization: Q4_K_M
Generation: ~50 tokens/s
Prompt processing: ~550 tokens/s
Configured context: 262K tokens
Runtime: llama.cpp
Optimizations: Flash Attention and Q8 KV cache
Running a model of this size on a 12GB GPU sounds unusual, but its architecture explains part of the story.
Why a 35B model fits this setup
Qwen3.8-35B-A3B uses a Mixture-of-Experts (MoE) architecture.
It contains approximately 35B parameters, but only around 3B are active for each token.
Instead of activating the entire model during every generation step, the architecture routes computation through selected experts. This reduces the computational workload compared with a dense model of similar total size.
However, there’s an important distinction: having only 3B active parameters does not mean the other weights disappear from memory. The full model still needs to be stored and accessed.
The solution is hybrid inference.
The reported setup uses llama.cpp to distribute the workload between the GPU and CPU.
Specifically, 26 MoE layers are offloaded to the CPU, allowing system RAM to hold and process parts of the model that cannot fit in the RTX 3060’s VRAM.
Two additional optimizations help manage memory:
Flash Attention: improves attention computation and can reduce memory overhead.
Q8 KV cache: stores attention keys and values in 8-bit precision, reducing cache memory requirements compared with higher-precision storage.
Q4_K_M quantization also reduces the model’s weight footprint.
Together, these techniques make it possible to run a much larger model on hardware that would struggle to accommodate a conventional 35B dense model entirely in VRAM.
One caveat: the reported 262K context is the configured capacity. It doesn’t guarantee the same speed or memory usage at every context length. Longer prompts increase KV-cache requirements and can affect performance, particularly on a system with only 16GB of RAM.
But the real test is agentic coding.
Generating 50 tokens per second is useful, but coding agents need more than generation speed.
They have to inspect files, understand an existing codebase, call tools, modify code, diagnose errors and verify whether their changes actually work.
The planned comparisons include:
Ornith-1.5-35B
Qwen3.8-27B
Qwen3.6-35B-A3B
Testing them through Hermes and Pi coding-agent workflows should reveal how well Qwen3.8-35B-A3B handles multi-step development, tool calls, debugging and recovery from failed attempts.
If it can complete those tasks reliably while running locally on a 12GB GPU, it could become an interesting option for developers who want capable coding agents without depending entirely on cloud inference.
The initial inference numbers are promising. What matters next is whether the model can turn that performance into reliable work.
I can't sleep after this shit... Claude Code just found 12,154 photos of my face on the old Android I used for 8 years. I never took a single one of them.
The front camera was firing almost every time I picked the phone up. In bed, on the train, in the car, or when I just grabbed it to check the time.
They were real camera frames sitting in a hidden folder, each one with a timestamp and a location. None of them were in the Gallery or in Recently Deleted.
I plugged the phone into my laptop, turned on ADB and told Claude Code to look for front-camera files that weren't in my photos. It pulled a folder inside Android/data that belonged to a flashlight app I installed in 2019 and completely forgot about. 12,154 files.
I started scrolling. Almost all of it was from the last 15 months. Then I saw a file created 2 seconds ago, while I was still looking at the folder. The phone kept taking photos of me as I was reading this.
On Android 8 any app with camera permission can shoot in the background, and you get no green dot or any other warning when it does. That flashlight app had camera and location access from day one.
I uninstalled it, took camera access away from everything that doesn't need it and cleared the folder. How many of these photos already went somewhere else, I don't know.
If you want to check yours, plug it in, turn on USB debugging and ask Claude Code to find front-camera files outside your Gallery and show which apps used the camera and when.
Xerxes Rånby retweeted
I used Divyansh's approach to build an entire Nintendo into ~1GB of Qwen3.5 weights.
Qwenputer, meet Nesformer: github.com/dbreunig/nesforme…
Xerxes Rånby retweeted
How did I figure out that natron dissolves granite?
With difficulty. First I had to forget what school taught me about stone.
Granite isn't some sacred, eternal material. Roughly three quarters of it is SiO₂, quartz. The rest is metal oxides: aluminium, sodium, potassium, calcium, iron.
(Just like wood ash. Remember that, it matters later.)
A Mohs hardness of 6–7 isn't a verdict, just a physical state. The real question is what breaks down quartz.
Glassmakers have known the answer for centuries: molten natron (Na₂CO₃) takes SiO₂ apart at 851 °C.
SiO₂ + Na₂CO₃ → Na₂SiO₃ + CO₂
What's created in the reaction is a strong glue, called waterglass. The main ingredient of artificial stone. Oops!
I tried dismantling a piece of red granite with charcoal embers, a tin can and washing soda (=natron). The result is in the photo, after removing the dry waterglass with a plastic(!) tooth brush.
Later, in my garden, I etched granite with NaOH and KOH separately, at around 360–400 °C.
This year, with a NaOH–KOH eutectic mix, 168 °C was enough. That's all it takes for the "invincible" stone.
I discovered nothing. Glassmakers, ceramicists and recyclers all know this.
Nobody had just connected it to the scoop marks on ancient stones. Let’s connect the dots, archeologists!
They trained a model on bytes!
This is truly genius and feels like how it should be done
I've always believed that intelligence should come from simple, general building blocks that learn their own abstractions directly from raw data; in other words, the bitter lesson. I think we're finally seeing a real step towards AI that can learn from all data.
Language modeling on raw bytes is a microcosm of this ideal, and to me it's a central problem in AI: if we can't build LLMs that learn end-to-end from bytes, how will we handle the rest of the world's data that we understand even less?
Last year we introduced hierarchical networks (H-Nets) as a first step. Our new version finds up to 3-5x efficiency gains in controlled scaling law experiments, and at larger scale matches an open-source model trained on 11T tokens with ~10x less data and compute. The posts below walk through what we found and why we think it works.
Xerxes Rånby retweeted
1/4
Meet Qwenputer: Qwen3.5-4B with a full RISC-V CPU inside its weights, using the model's own Gated DeltaNet layers as RAM.
It runs C and MicroPython in its forward passes, no external runtime.
On DeepMind math: base 55–90%, base + Python tool 95–100%, Qwenputer 97.5–100%.
Xerxes Rånby retweeted
Someone ported Haiku (the open source BeOS clone) to run on a Raspberry Pi 4.
Entirely with AI. With one prompt.
“Three days after the first prompt the Pi boots the regular Haiku desktop from its SD card or from the network.”
Including “OpenGL, OpenGL ES 3.1 and Vulkan 1.3 on the V3D GPU through Mesa”, three different web browsers, and Photocraft (the Adobe Photoshop clone created by AI).
“I asked the agent it to deliver a working version of Haiku on Pi4 end-to-end without ANY manual intervention. Starting with just one prompt. The agent had to download sources, figure out build system, figure out qemu setup, figure out pushing images to the test rig, implement changes, testing… and it worked!”
github.com/haiku-pi/haiku-rp…



































