I'm implementing query language with flex and bison for ccd because they do the job :-)

Example: !~G i ~f

This filters regular files, which are not in .gitignore.

1.0.2 with Arch Linux packaging files in addition to Debian:

https://codeberg.org/jarkko/libbasedir/src/tag/1.0.2

Instead fuzzy search or regular expression I will have mutt alike filter syntax in caffeine commander (ccd) with similar search modifiers.

#mutt

Pipewire daemon without systemctl (needed it this recently):

# In cat ~/.config/pulse/client.conf, set:
# autospawn = no

pid=$(pidof pulseaudio) && kill "$pid"
setsid bash -c '
  pipewire &
  PIPEWIRE_PID=$!
  wireplumber &
  pipewire-pulse &
  wait $PIPEWIRE_PID
' > /dev/null 2>&1 & disown

#linux #pipewire #note

One of the many reasons why Lua is my favorite scripting language, is that you don't need JSON, YML or TOML.

Lua works well for all those needs and purposes also as a data format.

https://arstechnica.com/security/2026/04/new-rowhammer-attacks-give-complete-control-of-machines-running-nvidia-gpus/

yes

https://tal-software.com/products/tal-j-8x

WDF circuit modelling and learning all about the topic has by accident become my hobby 🤷

It started by learning to model some existing analog gear based on circuit diagram and getting surprisngly good results.

I've cut out all plugins to their own Git project from the Clarity DAW project in order to trim it to something accomplishable.

From that stash I've further split 808 plugin project, and will redesign WDF modelled internals :-)

Always nice to learn a craft and I could imagine that this can be generalized to circuit simulation overall, which is professionally useful craft.

@timojyrinki, this could be useful to package to OpenSUSE. It has a proper cross-platform support:

https://codeberg.org/jarkko/libbasedir/src/branch/main/src/platform.

Good quality for what it does :-)

@nina_kali_nina I've actually done aoUT type of stuff also professionally back in 2012 when I implemented this in collaboration with Peter Anvin:

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/realmode

Basically just applied learnings from this :-)

This has spinned off from my recent side-projects and thought to release it because it is disturbing to reimplement this all the time:

https://codeberg.org/jarkko/libbasedir

There was not really great library to handle this simple task so here you go.

@nina_kali_nina I'll publish the links in this site once I release them: https://jarkkojs.github.io/

Thus, the 486 esque mode 13h fixed point graphics goodness with VGA's rectangular pixels :-)

@nina_kali_nina The inspiration came from when I noticed that people I know who are doing demoscene productions for MS-DOS still use old compilers and really antique tools to generate MS-DOS binaries.

An associated project is to create mxmplay20 of https://www.cubic.org/source/mxmplay-1.6.zip, which is portable implementation of the original and buildable also for Linux (with Pipewire instead of GUS playback routine).

There is a new GUS fork of ao486 that has gained my interested so I guess that it is the main target platform: https://github.com/xolod79/ao486_MiSTer/tree/GUS

Has been nice to hear the awesome sound of Gravis Ultrasound first time in 20 years :-)

@nina_kali_nina Cool. I'm releasing in near future aoUT dos extender with toolchain support for modern gcc and clang. The name comes from the fact that the PM payload is relocatable a.out :-)

As for Dosbox, this is AFAIK the best incarnation of it ATM: https://www.dosbox-staging.org/

https://codeberg.org/jarkko/ccd

Not yet active.

Extension mechanism available are file type handlers.

It neither has user defined actions nor plugins because I prefer kernel alike model where single codebase is further improved. And this guarantees ubiquitos UX for anyone using ccd (same shortcuts work everywhere). And these choices help to optimize performance given more predicatable CPU load.

If you want plugin type of robustness, there are plenty of options available. If you think that user defined action would make sense, implement it instead as an nternal feature, and forward me a PR.

Caffeine Commander (ccd) is a terminal file manager written in C, based on non-blocking file I/O.

All I/O operations are asynchronous, and UI and CPU tasks share a single thread, making the most of the available resources :-) And this obviously minimizes context switch latency while at it.

With ccd I focus on to single thread implementation including I/O :-) Two threads is way too much...

And it enforces to amortize workoads and other good practices that are too easily bypassed by a thread pool.

There will be soon need for a book "LLMless cookbook" for kids so that they don't fuck their careers with misguided beliefs and fantasies.

One recipe could be "build your own stash with local repositories". It's not really about any "secret sauce" but more like less friction to do random experiments from which to learn from. It's losless compression of *your own memory* whereas neural network is lossful compression of LLM model + generated additional interference based on material fed (fuck that was complicated to phrase lol, sick layered)

For a person like me, LLM generated implementation is +1 variation of thing that I could have, and literally always also have written manually. This is for expanding search space of alternative ways to branch code for instance. We're looking for quality over quantity after all, aren't we?

There is one recent example where I did use an LLM agents successfully and in very planned, instructed and sandboxed manner. I did a huge file recovery operation that reconstructed a couple of lost Git repostories from ddrescue dumps of three different computers.

Third example is actually a bit obscure but for rootns patch set that I'm working on I use a bug I've found in claude code to make the agent go insane by removing cwd beneath it while being overstressed with "impossible" workload.

What these examples show is that since I have the craft under control, even the use of agents is very "tool-oriented". The non-tool oriented use would be OFC compensating my own shortcomings.

AI companies are throwing a generation of potentially great engineers under the bus. That's sad to watch happening.

I have now also syntax highlighted source code viewer in ccd. I stole that out from tree-sitter code of a small text editor project that never really got going.

My stash of local repos over the year really is like a super powerful LLM for me at least or could not be replaced with any of those :-)

Preloader will mean +1 thread, which again only uses non-blocking I/O.

That's really as much one should use at most. Context switches are expensive and IO is mostly just waiting from CPU's standpoint.

I think user space programs advertising the size of their thread pool are made by developers who really don't understand what they are doing TBH 🤷