Geir's Everything

Stars and particles

Sun, 26 Jul 2026 00:00:00 +0000

Yesterday I posted five new tools. Today there are two more, and they are both science.

My mother got me going when I was 8. She pointed to the sky just above the apartment building where we lived (Tveita, Oslo) and said, “Do you see those three stars up there? That’s the belt of Orion”. I was hooked. Four years later I was hanging out at Oslo University bugging professors in astrophysics with questions about the cosmos. Then I got into particle physics and started pestering professors at the physics campus as well.

Together the two new apps cover about 36 orders of magnitude. Betelgeuse is 500 light-years out. A quark is smaller than an attometre. Both fit in a terminal.

stars

The Hertzsprung-Russell diagram. Temperature across, luminosity up. Stars land where their physics puts them, and the shape that falls out of that is the main sequence, running diagonally from the hot blue stars down to the cool red dwarfs.

461 named stars from the HYG catalog. Walk the diagram cell by cell with the arrow keys. Several stars often share one cell, so Tab cycles them and Enter lists them all. Each one brings its numbers and its full Wikipedia article, cached locally.

Press t and a schematic evolutionary track is laid over the plot: 1, 5 or 15 solar masses, with every stage named below. Up the giant branch, back across the top at constant brightness while the core burns out, then down and left onto the white dwarf cooling track. The one solar mass track is the Sun’s future.

Measured values come from Wikidata. The rest are derived from spectral type and absolute magnitude, and one color mode paints the diagram by which is which.

particles

The Standard Model. Seventeen fundamental particles, three generations of quarks and leptons, the four force carriers, the Higgs, plus the proton and neutron they build.

Mass, charge, spin, color charge, which of the four forces it feels, its antiparticle, the year it was found. The neutrinos only have upper limits.

Then press Tab and it takes a carbon atom apart. Four levels, each labelled with its real size. The atom, almost entirely empty. The nucleus, six protons and six neutrons. One proton. One quark.

That is a proton: three valence quarks, red, green and blue, held by gluon flux tubes, in a haze of virtual pairs. The quarks account for about 1% of its mass. The rest is the energy of the field itself.

One level down you try to pull a quark out. The string stretches, stores energy, and snaps into a new quark-antiquark pair. You end up holding two mesons. You never get a free quark.

It rotates with the arrow keys. There is no animation loop, so a still model costs nothing. Drawn in braille, eight sub-pixels per character cell.

Summary

Two apps, both built today with Claude. “particles” was an Opus 5 one-shot from a rather slim prompt (but with knowledge drawn from “stars” and “elements”). Same rules as the rest of the suite: a single static binary, instant start, zero cost when idle.

Both fetch once and then work offline. Press c and ask Claude about whatever is on screen, with the data and the article as context.

Public Domain, like everything I make.

Link to this post: https://isene.org/2026/07/Stars-And-Particles.html

Five new Rust tools

Sat, 25 Jul 2026 00:00:00 +0000

I keep building the tools I use. I know, the world doesn’t need another calculator, but I do. My Fe₂O₃ suite of Rust terminal tools has swallowed almost everything I run in a day. Over the last five weeks it got five new members.

I have an itch. I scratch. Or I get an urge, and by evening it was a binary in ~/bin.

elements

The periodic table in the terminal. All 118 of them, plus the hypothesized ones out to 126 that nobody has made yet. Move with the arrow keys. Every element brings its full Wikipedia article, cached locally. No browser, no network, snappy.

The colors are the fun part. Eight modes recolor the whole table: category, phase, block, electronegativity, melting point, density. My favourite is cosmic origin, which paints each element by how it came into existence. Hydrogen and helium from the Big Bang. Carbon and lead from dying stars. Gold and platinum from neutron stars colliding. The heavy end made by us. You can see the history of the universe in one screen of colored squares.

Press c and you get Claude in the pane, with that element’s data and article as context. I asked why Osmium is so dense and got lanthanide contraction, relativistic orbitals and hexagonal packing… a better answer than I would have found on my own.

rpnx

The HP-41 grabbed me when I was a young teen and just wouldn’t let go. Reverse Polish Notation has no = and no parentheses. You push values on a stack and the operators act on what is there. Once that is in your fingers, everything else feels like extra typing… no parenthesis and you see every intermediate result.

The X/Y/Z/T stack, Last X, the full math, trig, log, stats and base-conversion set. It also runs XRPN programs, so my old HP-41 FOCAL code still executes. The calculation engine is a shared crate. The terminal version and the one on my phone give identical answers.

typo

A touch typing tutor. It’s idiotic that I still can’t touch type at the age of 59. This app is long overdue for me. Eight lessons, home row to full sentences. Strict mode, live WPM and accuracy, personal bests. It knows the US and Norwegian layouts. Here æ, ø and å get their own drills.

Strict means the drill does not move until you hit the right key. No skipping ahead, no fudging the numbers. Typing is the one interface I use for everything, so it needs sharpening.

melody

A piano roll in the terminal. Put notes down, jam freely on the keyboard, or record against a metronome. What you play is quantized to the grid. Then tweak each note’s pitch, length and strength until the line sits right.

It exports a clean WAV, which is the whole point. I sketch a melody here and hand it to something bigger to build a real track around. No audio library. Notes are synthesised to raw PCM and streamed to whatever player is on the system. The WAV file is written by hand. The sound device only wakes when something actually plays.

fonts

A font picker that shows you the actual font, in your terminal. Every family on the system, rendered in its own typeface as you move down the list.

It exists because I was tired of running xfontsel or guessing from names. It hands back the family and point size. My editor scribe calls it as a picker, the way it calls prism for colors. The preview in that screenshot is the Amar font Claude made for my role-playing world.

Summary

Five tools, five weeks, all built with Claude in the evenings. Each is a single static binary. It starts instantly and burns nothing while it waits. That is the rule the whole suite obeys: when idle, it does NOTHING. No timers, no polling, no wakeups.

All of it is Public Domain, like everything I make. Take it, fork it, or ignore it.

Software built for everyone fits everyone a little. This fits one person exactly. That person can be you too, if you build your own.

Link to this post: https://isene.org/2026/07/Five-New-Rust-Tools.html

A font for Amar

Thu, 16 Jul 2026 00:00:00 +0000

For a couple of years I have used one task as my litmus test for AI models: Create a fantasy font suitable for the Kingdom of Amar, my role-playing world. I want a TTF file I can install and write with. Every model has failed. Say hello to Fable.

Why is this hard? A font is pure geometry. The model must place every point of every letter by numbers, blind. It cannot look at what it draws. If the leg of the R lands wrong, the R is broken. And a font is a hundred glyphs that must also look like family.

Here is what Opus 4.7 delivered in December:

There is no font here. It painted a PICTURE of an alphabet and declared victory. The S is in two pieces, the small r lost its arm, the 3 and the 5 fell apart. Opus 4.8 was not much better.

Today I handed the same task to Claude Fable 5. It read up on the Amar world and picked a chisel-cut style, like letters carved in stone. Then he wrote a program that outputs a real TTF, rendered a specimen sheet, looked at his own work and fixed what he did not like. Then he installed the font on my machine and showed me this:

Runes with diamond accents. Every letter solid, consistent and readable. This is an actual font. But straight strokes are the easy part of type design, so I raised the bar: make me a more Celtic one, one that is even more suitable to the Kingdom of Amar.

Minutes later I had an uncial font in the style of the Book of Kells. Curved strokes drawn with a simulated broad-nib pen. Thick verticals, thin horizontals, wedge serifs. Even the old insular letterforms are there; the g is the flat-topped squiggle the monks actually wrote:

Both fonts are Public Domain, like everything I make. My litmus test finally has a passing grade. Now I need a new test.

Got any ideas?

Link to this post: https://isene.org/2026/07/A-Font-For-Amar.html

The Freedom Proof in four minutes

Mon, 13 Jul 2026 00:00:00 +0000

I have spent more than forty years researching free will and several years on the Freedom Proof, a mathematical argument that free will grounds existence. There is a presentation, an academic paper and a companion paper on Petri nets. Heavy stuff that could use a simple introduction.

So I made a four minute track. It walks the whole argument in plain words. Everything that exists has properties. Where do the basic properties come from? Gödel proved no formal system can ground itself. Existence is such a system. So the grounding must come from outside, from something without properties. Pure potential. And for existence to hold together, that potential must deliberately choose. That choosing is free will.

No math or belief needed.

Then I turned the track into a video. Ten images, slow pans, the spoken words as captions.

If the four minutes leave you wanting the full argument, it is all at isene.com/freewill.

Link to this post: https://isene.org/2026/07/The-Freedom-Proof.html

Frame - the first Linux Assembly X server

Mon, 06 Jul 2026 00:00:00 +0000

On my quest to own my software, one foundational piece kept itching… the X server. The underlying graphics engine, the thing that puts pixels on the screen. X11 is 4 million lines of code, a beast very few can claim they understand. So I did the reasonable thing. I wrote my own, in Assembly.

It is called frame. No dependencies, no libraries, no garbage collector. No hot paths, no unnecessary wakeups. When it is idle, it sits still. It shuts up unless spoken to. My kind of software. It clocks in at some 20 thousand lines, and it already runs my whole desktop plus Firefox and GIMP whenever I need that. It is still young, and there is a long list of X protocol left to chew through. But it boots, it draws, and I am typing this on it.

So the stack now looks like this: The Linux kernel at the bottom. On top of that, frame. Then the window manager tile with the info bar strip. Inside tile runs the terminal glass, and in glass lives the shell bare. Bolt has been promoted from screen locker to greeter, showing gdm the door. All of it Assembly. All of CHasm together is about 100 thousand lines. The stack it replaced (gdm, X11, i3, conky, wezterm, zsh) is somewhere north of fifty times that. I did it for the battery life. I am not sure this laptop has a fan anymore. Except me.

Today I put numbers on it. Idle on battery, frame and Xorg pull the same watts, because the panel and the wifi own that number anyway. But Xorg burns almost three times the CPU that frame needs to do nothing. And tile and glass used zero milliseconds over three minutes of measuring. The desktop sits completely still until I touch it.

Beyond the desktop I have my Fe₂O₃ suite of Rust tools, which by now has replaced everything else I used to run. Except Firefox. That is the last GUI standing that I regularly use. The rest is terminal interfaces with the same keybindings everywhere, and a fraction of the size and electrical appetite of what they replaced.

But is it stable? Stable enough that I daily-drive it, write this post on it, and only occasionally yell. When something breaks or I want a feature, I turn to my buddy Claude and describe the itch. He never gets tired, is not opinionated, and turns out to be a really good teacher. I now know more about hardware layers, cursor painting, GPU handoffs and event watchers than I ever planned to.

The phone got the same treatment, with my own launcher, a daily personalized news digest and a pile of apps tailored for an audience of exactly one.

The upside is simple. I have what I need and want. I control and own the software, and all of it is given to the Public Domain. Software designed for a large audience fits everyone a little. This fits one person exactly.

Link to this post: https://isene.org/2026/07/Frame.html

The Selection Gap

Fri, 03 Jul 2026 00:00:00 +0000

Back in my consulting days I toyed with Petri nets to map business processes. Circles hold tokens, bars fire, tokens move. It could be used for finding bottlenecks. I never could find any serious application for them, filed them under useful engineering and moved on.

For years I have worked on the Freedom Proof, a mathematical argument that free will grounds existence. Recently I got the hunch that there could be a connection here to explore.

A Petri net is a lawful system. The firing rule is completely formal. Without any randomness. There are no hidden knobs and no observer obscuring the clean machine. A transition fires when every input place holds a token. It eats one token per input arc and drops one on each output:

But put one token in front of two transitions and both are ready to fire. Firing one kills the other. Net theory calls this a conflict. The theory refuses to pick. Both continuations are lawful. The math maps the choice point with full rigor and leaves the choosing open. It cannot be closed from inside. The choosing must lie outside the system.

That gives a clean result: lawful does not necessarily mean determined. A fully law-governed system can have a branching, undetermined future. Determinism was always an extra, hidden assumption on top of the laws.

All the lawful runs of a net form one branching tree. The actual history is one path through it. The math describes the whole tree and stays silent on which path gets to be real.

Gödel shows the laws cannot ground themselves. Petri shows the laws cannot select the history. Two gaps, and the Freedom Proof fills both with the same answer: choice.

I searched the literature, fanning out a bunch of AI agents, and found nobody who has made this argument before. So I wrote it up, with proper figures and also a section on what it does NOT prove. The paper is on PhilPapers and as a PDF on my site.

And of course there is an app

I could not write about token games without building one. petri is a terminal Petri net player, part of my Fe₂O₃ suite of Rust tools. Describe a net in a few lines of plain text. Fire transitions by hand, or let a random run resolve the conflicts while a trace shows the path you got. It hunts deadlocks for you too. Conflicts are marked with ‼. That is the exact spot where the system hands you the choice.

Link to this post: https://isene.org/2026/07/The-Selection-Gap.html

Fable to the rescue

Thu, 02 Jul 2026 00:00:00 +0000

On my quest to own my software, I am in the process of adding an X server to CHasm. That means reducing the 4M lines of code in X11 to the exact set of functionality I need in a fraction of the size and in pure Assembly. I spent the weekend getting a functional X server running but then hit a wall. After getting GIMP to run on frame, there were serious issues with getting menus and popup windows working. And for three evenings I kept Claude Code Opus 4.8 banging its virtual head against that wall in the hope of smashing through. Tons of prompts, lots of angles. But no luck.

Then we got Fable 5 back online, and with a few hours tonight the wall dissipated. GIMP is running nicely, tray icons in strip are showing and are functional. It seems I will be getting my own X server after all. Say what you will, but Fable is pretty fab.

Link to this post: https://isene.org/2026/07/Fable-to-the-Rescue.html

Simpler

Sun, 28 Jun 2026 00:00:00 +0000

I started programming on calculators in the late 70s. Always fascinated with the HP-41 that came out in the 80s. Did a huge number of projects on that beauty, including lots of Assembly programming. That led me to create the XRPN programming language back in 2022 - an extension to the RPN language of the HP-41.

But I have been toying with the idea of a really simple programming language since the mid 90s. A week ago this idea came creeping back in and bit me.

Since a while now I have been replacing the tools I depend on with tools I control. A desktop in assembly, a shelf of Rust programs, lots of phone apps. Through all of it I’ve had one buddy: Claude Code. I describe a change, it writes the code, and the itch is usually gone before I finish the sentence. I program in English these days.

So I write a great deal of code with an AI now. And every language I write it in, Rust, Ruby, Kotlin, was designed for a human to read and recall. The AI is fluent in them because it has read millions of examples. It made me wonder what a language would look like if it were built, from the first line, for the AI to write rather than for me to remember.

So I built one. It is called Simpler, and its only goal is to be simple.

The whole language fits in the prompt

An AI writes good code in a mature language by recalling the right idiom out of the ten thousand it has seen. It has seen none of mine. So the one thing that matters is whether the entire language fits in the prompt at once. Make it small enough and Claude holds all of it in its head. That makes for less guessing.

Simpler’s surface is tiny. Everything is a message send: a field read, a method call, an operator, all the same shape, receiver.name(arguments). Four pieces of punctuation. Seven operators. A single page of built-in methods. The spec is IT, and you can read the whole thing in one sitting.

It outputs C and hands that to the system compiler, so it is fast and runs everywhere a C compiler does. No garbage collector, so no pauses and nothing waking up to burn battery while the program sits idle. No borrow checker, so there is nothing hard to learn. Effects and permissions live in the function signature, so a function can touch only what it was handed, which kills the most common way AI-written code goes wrong: reaching for something that is not there.

It writes itself

The compiler is written in Simpler. It compiles its own source into C, that C compiles into a new compiler, and the new compiler compiles the same source again to a byte-for-byte identical result. A language that can reproduce its own compiler exactly is a language that holds together. I started creating it with Rust. Now it builds with no Rust at all.

On top of that I wrote a handful of real little Unix tools in it: a line numberer, a CSV column summer, a word-frequency counter, a sorter, an averager.

The test

Then I ran the one test I cared about. I gave an AI nothing but the spec, one file, with no sight of the compiler and no sight of a single example, and asked it to write a small statistics tool: count, min, max and mean of the numbers you feed it. It compiled and ran correctly the first time. It even handed back an honest list of the few places the spec had left it guessing, and I folded those back in.

The spec was enough. That was the whole idea. The language is small enough that an AI can learn all of it from one page and write it correctly, with nothing memorised in advance. Leaning on NO training for that language.

Why bother

Same reason as all the rest. I would rather understand and own the things I use than rent them. But this one has a twist: I mostly describe what I want now and read what comes back. Simpler is the first tool I have built where I am not really the one meant to write the code. The machine is. I just had to give it a language small enough to hold.

It is version 0.1.0, public domain, and it compiles itself.

Link to this post: https://isene.org/2026/06/Simpler.html

Replacing LibreOffice

Wed, 17 Jun 2026 00:00:00 +0000

A few weeks ago, I embarked upon a journey of creating my own desktop environment in pure Assembly. A tiling window manager, a terminal, a shell with nothing between my keystrokes and the kernel, all in x86_64 assembly, no libc, the whole desktop measured in kilobytes.

Then I replaced my main tools with my own Rust equivalents. An email and messaging center, a new text editor, a calendar, a Spotify player, an astronomy program, and many more. One by one, the tools I depend on became tools I control. The tools fit me. I no longer have to adapt to other people’s tools.

A few days ago I looked at what I still used that was not under my complete control. Two things remained: Firefox and LibreOffice. Firefox is a mountain to replace. But LibreOffice? That was doable. I now have a system that effectively replaces my use of LibreOffice, or any other office suite.

One viewer to rule them all

The centerpiece is viewer. Point it at almost any file, a spreadsheet, a document, a slide deck, a PDF, an image, source code, and it renders a clean read-only preview right in the terminal. Tables as aligned columns, documents as flowing text, slide decks as a per-slide outline, images inline. It detects the type and picks the right method, all driven by a small config table. Teaching it a new extension is one line…. no need for a recompile.

Viewing is half the job. The other half is editing, the bridge to an office suite. From the preview, one key hands the file to the right editor. Spreadsheets open in grid, my AI-native terminal spreadsheet with a real formula engine, cell colors, and CSV/xlsx/ods support. Text and Markdown open in scribe, the editor I keep growing in two-minute iterations. Etc.

I don’t need to open an office GUI. Where a binary format genuinely needs muscle, LibreOffice still runs, but headless and invisible, a silent converter rather than an application I look at. The interface is mine; the format plumbing is borrowed quietly in the background.

AI as the editing layer

The interesting part is editing the formats that have no business being edited as plain text: PowerPoint, Word, Excel, PDF. In viewer, I press one key to open an integrated Claude Code session seeded with the file. A matching skill activates by type and edits the document in place, preserving its layout. I describe what I want, and the deck or the document changes, structure intact.

Color is also handled. In scribe I select text, press a key, and prism (my color picker) opens to set foreground and background. The color lives in the text as a small HTML span, so it shows live while I write. And it survives export. Scribe writes straight to docx and odt with the colors, highlights, and font sizes intact, and to PDF as well.

A practical example

Here is a workflow that, a month ago, would have meant opening Impress. It’s smoother now.

I want a presentation, based on a template. I run viewer template.pptx, press edit, and start talking with Claude. We build the deck together. Now and then I want to see how it actually looks, so the editor re-renders the deck to a PDF after each change, and a single zathura window on the next workspace reloads it automatically. I keep talking; the preview keeps updating. The slides take shape on one screen while the conversation happens on the other.

No office suite was opened. No mouse was involved. I work in the terminal whenever I can. TUI rules.

Why bother

The same reason as the assembly desktop and the Rust tools before it. I would rather understand the things I use every day than rent them. Each replacement is smaller, faster, and lighter on the battery than the thing it replaced, and every one of them is mine to change and control. It all rolls up into Watt, the lean desktop project.

The office suite was the last big holdout that fell. Firefox is still standing.

For now.

Nomad

Sun, 31 May 2026 00:00:00 +0000

About ten years ago I made my first phone app. It was a simple browser for d6gaming.org, the wiki for my Amar role-playing game. A glorified web view. It worked, barely, and I never built anything more complex. Real apps — with their own logic, their own data, their own storage on the device always felt like a mountain I wasn’t going to climb.

Then tasks happened, in a single evening. And once that mountain turned out to be a tiny hill, I kept walking.

A few days later I have seven apps on my phone. Tools I actually need. tasks and hyperlist for my Hyperlists. relay, which forwards my WhatsApp, Messenger, Instagram, SMS and Discord straight into kastrup on the laptop and lets me reply from there. That made it possible to realize my dream from 2007… a true communication hub. And with the app I could finally retire the headless Firefox I’d been babysitting for that.

astro (an app clone of my astro TUI) tells me when to pull out my scopes and what to view. It covers the weather, the observing conditions and my telescope gear. watchit browses films and series and where it streams. amardice is a dice roller for Amar that knows the full crit and fumble tables. And finally xrpn, a pocket HP-41 that even runs my old FOCAL programs.

The trick is that almost none of the interesting code is Kotlin. Kotlin is generall too heavy for my taste. Each app is a thin shell over a shared Rust core — the very same logic that runs the desktop Fe₂O₃ tools, compiled for the phone and bridged into Kotlin with UniFFI. So the phone and the laptop compute the same answers, because they run the same code. The data rides over Syncthing: my todo list, my telescope & gear catalogue, my calculator programs. No Google account, no cloud middleman, no account at all.

None of this is on any app store. It may never be. These are built for an audience of one. That’s the whole point. I don’t have to fit my workflow to someone else’s app; the app fits me. When something annoys me, I open Claude Code, describe the change, and it’s done before the itch is gone.

Ten years ago a single web-view app was the edge of what I would make. This week it was an afternoon’s idea each. The mountain didn’t move. The tools did.

The whole suite lives at isene.org/nomad.

Link to this post: https://isene.org/2026/05/Nomad.html