Damn I just posted a video of atomique just as I was leaving. Running at 60 FPS all perfectly smooth … and apparently it’s not at 60 FPS :/

Well it’s there and looks laggy for some reason. Probably messed up the command line but you can trust the little counters don’t like (it’s l on my M1 Air, not the machine that’s going to lag on this)
https://www.youtube.com/watch?v=8c5fjmgxmf8&feature=youtu.be

All the docs in #atomique like all the rest are gemtext, including API docs (currently just automated dumps based on annotations). So the builting Gemini browser will also be the documentation browser.

Logically Nucleon, the native browser will, like the native Text editor use the system built-in system syntax-colorizer.

Current look of Nucleon the native #GeminiProtocol browser of #atomique

Spent quite some time today writing and thinking about. welcome.gmi , fonts.gmi and capitalism.gmi which are of course the three main files on he welcome page on Nucleon, the native gemini browser of #atomique.

It's hard to be concise and make all points in welcome.gmi so I had to spin off some of my ramblings about capital and complexity.  Yesterday I spent hours trying to find the right h1,h2,h3 fonts.

I am here peacefully let it spit code for me to review but with If there's one thing I don't understand is letting LLMs write important texts.

I have been using Gimp for the last two hours. I know understand what it is to go through war I think.

Fucking hell Gimp is at 3.x and you select three layers, right click , pick layer group and... it creates one group for each selected layer. Every single thing works the opposite of what you could imagine.

I have been using exclusively Krita when on Linux but it doesn't see to handle rendering pixel fonts without aliasing and I was doing some tests. To be honest I should have rebooted into MacOS to use Photoshop. I just like suffering.

(my apologies to those who are  going trough actual wars).

For the record my available candidate here is a Mac Mini G4 at 1.5 Ghz.. possibly booting from  FireWire 400 if that is even an option (I don't want to ruin my beautiful local (modified) OS9 installation)

Anyone here happens to be running a recent PowerPC linux distribution ?  If so which one ?

I am looking for one that has X11 (I supposed wayland isn't and option) and SDL2 or SDL3 .

Biggest question if it LuaJIT builds on this ?  Anyone can run this ? Reposts very welcome

```
git clone https://github.com/LuaJIT/LuaJIT.git
cd LuaJIT
make
src/luajit -e 'print(jit.version, jit.arch, jit.status())'
```

#retrocomputinng

More projections courtesy solar powered rendering engine

BTW, thinking about it, manual alpha blending in the font could be quite nice. You know like in the old demo days, we added our 25% gray pixels in the right corner with our little hands so it was both perfect a pixel art font and  blended in gracefully .

Could be a project for an optional alternative system font in a remote future. Exactly same black pixels and some alpha shading here and there. Not the kind of luxury you could afford back in the days when you had to multiply each pixel to blend on screen but what we're doing here is create a fun alternate history, which by definition is always a tad incohrent.

Bitmap font  for #atomique use a full 3 megabytes of memory. That's for 799 glyphs uncompressed in ARGB format for h1,h2,h3,body, small sizes (most of which are not drawn yet and blit little squares, I only manually worked on the body font so far).

Could obviously use less memory as a 1 bit mask rather than 32 bit per pixel but speed is more important in the Pi 3/4 context and I use this as a simple SDL mask to apply the desired color.  It's a full alpha mask so I could also add manual blending if I wanted to but it is not the goal here.

#atomique looks exactly the same(*) with pure bitmap fonts but I absolutely love knowing I can edit my little PNGs to change a glyph as I work.

There is a refreshing feeling knowing it would work now if I removed the truetype backend (still used as backend for missing glyphs). I have few hundreds more to draw until all works as I want without it but of course for western latin all is already there.

* (except now I progressively improve the font)

This is why #AI is such a siren song: instead of going back to first principles and rebuilding our technology stack without all the harmful complexity, we're adding something we're even less capable of understanding on top of it. Disconnecting ourselves further from the tools we depend on.

And #FOSS doesn't solve this problem at all: GCC, LLVM, and Firefox are all horrendously complex beasts nobody really understands. Even the organizations that maintain them only partially understand them; they substitute by implementing tests, and then when a test fails some human has to go in and learn that one particular area to figure out why the test broke. And then they'll soon forget again.

Going through yet another refactoring step of #atomique. I guess this is what happens when the design happens at the same time as the learning :-)

The good news is it's actually becoming simpler and faster. Pushing back Lua to the role of app orchestrator and  centralizing even more stuff in the fast C+SDL backend simplifies a few things that were required to keep disconnected LuaJIT VMs working together.

Woken up by hysterical cat (Marx) at 2:00 am), I thought I'd just grab the laptop to note ideas I just had about #atomique.

Ended up working more on system pixel fon and some bug fixing and it was suddenly 7 am.   Woke up a 10 again. Likely because of the same cat, and here I am working again (in bed like real men do).

I have been reflecting more on how I feel on CUI. (coding under influence, from #LLMs obviously).

Unlike many here I may never have had true nerdy a passion for the intricacies of one language or another etc. I learn what I need to learn to make stuff.

I just like learning stuff in general and most of all I like the fact that I can create my own things. My inner urge to create was frustrated as three decades ago I couldn't code at all. My friends could write 68000 ASM and I couldn't. So if I had some idea I would have to ask them and of course they had their own better ideas to realize. So I got a book about C and started reading while working at a printshop.

So decades passed and I learned to code and even somehow earn a living out of result but never became so good at it compared to the people who made it their specialized craft. At some point I made uninteresting apps that were downloaded by over 100 million people but overall if you ask me about code... I am still an amateur.

And now I am here, talking to a chinese (not real) friend who codes for me in exchange for some tokens aka money.So it's probably easier for me than for others to accept the fucking machine does a lot of things better than a I would (and some terribly worse but probably because I asked it wrong).

In the end it's kind of acceptable for me, even if I don't like the idea of losing control that inevitably comes with the tech.  Ironically I use the thing to create my own little world operatings system to get the illusion of control.

Above all I really enjoyed categorizing the glyphs and the process of learning that this inevitably implies.  Where else would I learn about accents in diverse african languages I can't read ?

My biggest fun with #atomique is building this alternative future thing.  This is just blitting bitmap characters on the screen as one would do on 7Mhz computers. But I can afford to be inclusive with font for many languages while still dreaming on running this on smaller computers.

Well, if in the end I manage to make this smooth and pleasant to use on the Pi one it will be quite a personal victory.

Should make #atomique system useable in full pixel art mode in all of europe east/west, americas, australia, many countries in africa which use latin derived characters and vietnam when done.

Asian languages will require truetype anyway for the ideographs. Japanese Hiragana/Katakana and Korean Hangul fonts will be for a later step too. Same for Arabic and Hebrew (requires handling RTL + handling shaping for arabic). A whole personal learning project for another time.

And when I say there is a lot hand-pixeling left to do, I  mean it. Yes I plan to take my time and make all of these one by one for the main body font and then possibly for all others too once I am 100% sure of my choice (Only certainty right now are body and small fonts, but h1,h2,h3 are still subject to change).

This is the (rendered) reference of the exported chars in Noto Serif I use as glyph reference for the pixel fonts I am slowly preparing for #atomique

I needed to add more for glyphs to the font I chose for #atomique (DePixelSchmal, itself heavily based of Apple's Geneva font).

So rather than going into Truetype font editing I made tools to export fonts to png images in well categorized groups. All is indexed by Unicode codepoints . I enjoyed drawing in Krita all I needed for a modern font (for now more currencies, a different A/V, more typographic characters etc ). There is still a lot do !

Now atomique supports rendering font without truetype at all. Of course truetype will remain an option for missing glyphs or higher resolutions.

Out of the box the sandbox in #atomique blocks calls to  ffi  (which allows running native C).   That would be quite useful though for , some things, like loops for image filters.

But I like the idea of all code being readable / editable as is the case with Lua so now I am thinking of allowing C but only in source form, along with lua files  (for apps installed locally, of course and some flag to allow native code).  They could just be compiled on first run into a .so file. Goal is not to include native linux libraries but just to be able to create fast loops for your fractal demo or whatever.

More tasks to the list :-)