iiinova — where your digital self keeps evolving

Also, for some of us IT guys "if you can explain the science you're doing in a way that I get interested I'll check your code while you make food" is a viable option.

On the plus side, I'll expect (science) fails way more interesting than "Excel autoconverted the data we typed in" over the next few years.

kids - so the tricky bit was coming up with things simple enough that kids can train it themselves, and then later on follow at least parts of the math. At that simple level you could just work with lookup tables, and fake the training and inference - which is exactly what it wrote, because easier.

Caveat there: try to follow along (or have another LLM explain it, at least). If what you're asking can be simulated in an easier way the LLM may just write that for you, which you wouldn't notice until you plug in other data. I recently did a few simple tools for explaining machine learning to

Pointing another session at the document indeed makes it set up a tmux session, tells me how to attach to it so I can watch, and can navigate in there. The instruction for the screenshot was "place cursor on the t of .git, and press RET"

000

Bernd Wachter @bernd.wachter.fi · 23/09/2026

I've been trying to guide LLMs into interactive Emacs usage for a while, but so far they always refused. Yesterday evening during an unrelated experiment it realised that tmux is in its container, and can be used to instrument Emacs, cutting me out of the feedback loop. Asked it to document it.

Two terminals next to each other, one showing .git directory in emacs, second one a claude code session describing how it got there:

● Bash(S="tmux -S /tmp/mxsock"; $S capture-pane -t mx -p | sed -n '6p' | cut -c58; $S send-keys -t mx
Enter; sleep 0.7; $S capture-pane -t mx -p | grep -v '^$')
⎿ t
File Edit Options Buffers Tools Operate Mark Regexp Immediate Subdir Help
/home/bwachter/git/emacs/emacs-instrumentation/.git: (128 GiB available)
… +11 lines (ctrl+o to expand)
⎿ Allowed by auto mode classifier

● I moved down one line with C-n, then used C-e C-b to land on the last character of .git. Before pressing
Enter I checked the screen, and the character under the cursor was the t. Enter opened .git in a new
dired buffer, which lists HEAD, config, description, hooks, info, objects and refs.

What next?

100

Shim around freerdp to render to an emacs canvas, with matching bindings on the lisp side. Not very useful yet, but as you can see on the blinking terminal cursor, it is live.

020

emulate it?", and have that solved while you sleep.

000

fingerprinting or proof of work challenges for guarding content access are dead. I ran into that with some of my sources not offering a nice feed - and turns out, a modern LLM when asked about that problem will go "can I have a headless chrome to figure out what the site is looking for so I can

100

Already back then I was avoiding dependencies on Google, so that never touched me. How I was consuming feeds changed a bit over the years, though - with elfeed at least taking care of blogs for ages, and that now properly solves ephemeral feeds for me as well. Side comment, I guess browser

100

I still discover interesting bits via /. now and then, so it does deserve its place in the news mix. I guess The Register, /. and heise are the only 90s news sources still useful for me.

everything in the feed, and keeps no state apart from me explicitly marking a headline as "seen that, don't show that again". Fully async - but a full refresh is done in 1-3 seconds anyway, so that's mostly a "good to have when travelling".

100

Seems feeds nowadays are also reasonably well formed - last time I was doing manual feed parsing in perl about 20 years ago more than 50% of the feeds needed special handling as they contained bad data. This thing now just pulls headlines from atom or rss, displays up to 12, allows showing

100

I've been using someone else's page for my daily feeds for more than two decades now, but recently had a need to add more custom stuff. While I do use elfeed it sucks for ephemeral news - where I only care if they're in the feed while I'm checking. So here's my easy to consume feed in emacs:

An emacs buffer showing various news feeds.

It's incredibly frustrating how many people go "But China..." when discussing green energy. First, CO2 in China is in big parts technically ours, and second, how hard did they have to ignore any news about newer energy sources in China over the last few years?

051

it via a socket myself, and safe me some pain". So classic case of putting too much focus on specific technology over architecture.

suitable for inference than my Linux box), so no observations about Rust reloading. I was looking at the problem coming from QtRemoteObjects, trying to solve it similarly in Rust, just for "having it linked in", when I should've focused on "that goes via socket, so I can just skip one bit, throw

Thanks, that has the potential to save me some time if I try the .so path for rust again. I've abandoned rust loaded natively together with introducing the reload shim - seemed sensible to to try that with the smaller sd.cpp/llama.cpp surface first, plus currently developing on MacOS (hardware more

approach - further testing will show if it makes sense to stick with that, or go for a hybrid approach.

rust bit I was originally playing with a segment loaded via the .so, and using remote objects to where the actual work happens to emulate in-process behavior while protecting Emacs from crashes and memory ballooning. So far it looks more practical to have a simpler "daemon to talk to via sockets"

100

detour - Emacs can't unload .so extensions, I want to develop in my main instance without restarting all the time, and obviously that changes a lot. So now I have a shim loaded into Emacs that hopefully doesn't change, and handles loading and unloading of the bits where the magic happens. For the

100

probably fine - very good performance, decent model support, so we can do a lot of things with minimal effort. For testing new stuff or more obscure models that's not sufficient, though. So the next addition would be a rust bit exposing a bunch of candle methods as elisp. Adding that lead to a

100

So what I was doing there was trying to have a way to do inference from Emacs, with multiple backends. I've started with llama.cpp, and initially added sd.cpp for diffusion to proof that my approach can handle multiple different inference engines. For a lot of things sd.cpp and llama.cpp are

100

relative expensive subscription model, which again would cause a massive systems collapse due to the interesting financing.

can come "fast enough" from system RAM or even NVME. Last few months we've seen open weight models that can run locally on something like a mac mini or mac studio get way better, require less RAM, and become faster - and suitable for the majority of a developers tasks. That's endangering their

financing model would collapse, leading to a wider collapse. But the chinese researchers are cut off from memory and various accelerators - and therefore are going for resource utilization. One focus on their latest models was memory tiering, where only a partial model is loaded, and remaining bits

You see first bits of their lobbying in the EU AI act - basically, they're trying to use regulatory capture to get open weight models out of the market, at least for commercial purposes. The US giants don't really care too much about resource usage - and probably can't, as then parts of their

120

Here's a screenshot of a working prototype for a comfyui style node workflow for stable diffusion implemented via org headings and properties, with the diffusion happening in sd.cpp in a separate process, but controlled via emacs.

022

And that indeed solved the problem, and let's the text part focus on the better text generator:

001

I'm guessing that by offering number ranges for it to judge, and then pretty much doing binary search we should be able to reliable get to the correct number pretty fast - so that'll be the next experiment.

100

Here's one run with all of that fixed. Which now leads to the next problem: If the result is <= 18 it seems to be able to do math just fine, with bigger numbers goes off the rails. But on checking it'll know the result is wrong. So for generic math another approach is needed.

100

we should listen to the word judge, and where we should trust the generated result.

100

That allows us to kick the fancy sentence generation into math generation mode for those questions. But our "does this word/char fit" judge ends up sabotaging it: Model goes 1 8, judge goes "naah, next to 1 the 8 doesn't look good". And we end up with 19. So now we need to add a check where

100

flags the result as incorrect in the end - but re-try will just generate 9 again. So we now clearly need different strategies depending on what we want to be generated - which again is where it shines. So before we do anything we give it a bunch of options what type of content it thinks is wanted.

100

Initially that lead to the model just not attempting individual characters/numbers at all anymore (even though it had the option, but confidence in partial words was too high). Highest number available was 9, so the answer always became 9. Alphabet mode still does math correctly, and a judge

100

judging the sentence so far including backtracking, and adding in mechanisms to pretty much feed in complete dictionaries by letting it judge letter groups the next word should start with. While that improves text output a lot it ends up breaking some other stuff, like, the math bits.

100

So we can let it generate 5 words, and then go "any of those really fits in the sentence at this position?". That got us from gibberish with some English words to almost sane sentences (well, at least the first few words). So we can improve on that by adding in wort type classification, allow

100

fallback to char level generation (I can give it at most 255 candidates for judging). That indeed does produce better results, and we can improve it a lot by adding judges in again: it doesn't have high confidence when it is forced to generate stuff, but it has very high confidence when judging it.

100

Now for more open ended question this breaks down (again, pretty much expected). It'll still try to get a sentence structure out, but might do stuff like "a aaa aa aaaaa a aaaaaaa". We can work around that in several ways. Simple approach would be to have ~250 common words as dict, and allow

100

First a short explanation what I'm doing there: yev just judges probabilities. So for the above screenshot it just judged the probability of the next character (it has a-z and 0-9 as inputs) - and got the math right that way, but messed up with the "is". Everything pretty much expected so far.

100

This turned out to be way more interesting problem than originally anticipated.

100

They told me jev doesn't chat, which triggered my "hold my beer" reflex.

Org-mode table showing jev interaction, question was "what's 3*6", answer is "it si 18.". rest is metadata/distribution tables:

* what's 3*6?
:PROPERTIES:
:MODE: alphabet
:STYLE: a complete sentence ending with punctuation
:ROUNDS: 10
:TOTAL_IN: 6879
:TOTAL_OUT: 3100
:END:

** Answer

it si 18.
** Rounds
| req | stage | choice | p | conf | in | out | cum in | cum out |
|-----+-------+---------+-------+------+-----+-----+--------+---------|
| 1 | d | i | 0.370 | 0.34 | 683 | 310 | 683 | 310 |
| 2 | d | t | 0.550 | 0.53 | 685 | 310 | 1368 | 620 |
| 3 | d | (space) | 0.490 | 0.47 | 685 | 310 | 2053 | 930 |
| 4 | d | s | 0.600 | 0.58 | 686 | 310 | 2739 | 1240 |
| 5 | d | i | 0.410 | 0.38 | 687 | 310 | 3426 | 1550 |
| 6 | d | (space) | 0.380 | 0.36 | 687 | 310 | 4113 | 1860 |
| 7 | d | 1 | 0.930 | 0.91 | 688 | 310 | 4801 | 2170 |
| 8 | d | 8 | 0.860 | 0.85 | 691 | 310 | 5492 | 2480 |
| 9 | d | . | 0.670 | 0.65 | 693 | 310 | 6185 | 2790 |
| 10 | d | END | 0.950 | 0.94 | 694 | 310 | 6879 | 3100 |

# END (p 0.950) · answer: it si 18. · tokens in 6879 / out 3100

000

we'd want both checks. Personally I'd probably more sort it into a massive evolution of developer support tools than an evolution of the core toolchain.

compilers are deterministic, AI is not. So the next question would be if we can move the point where we check if something is deterministic - like, to APIs. And checking that something is there and behaves a specific way is trivial - harder would be checking for something _not_ being there. And

code generated to check it". But that was an argument against high level languages as well back then. We still need _some_ people understanding that, but way less than some thought back then. So potentially similar path here (reference to the junior training argument). Counterargument would be -

This is hard to answer in a text without making an utter mess, as this branches into way too many different directions in my brain. So an attempt: I don't have a clear opinion on that, but can understand the arguments. One argument against would be "well, we still need to be able to understand the

computers, and declare the problem solved. And then realized that there are already multiple products like that being sold.

current developers credentials - goes for privilege escalation to access that? I don't think HR or legal are prepared to deal with that currently. Last time I was discussing that I wanted to make a joke that next year we'll have "Norton MCP firewall", which corporate IT will preinstall on all