Currently trying to write down precisely what I don't understand about the logic in this org markup parser I wrote in C for #weewiki. It's fun to be confidently uncertain.

Speaking of 1-bit, here's a #monolith wiki page I just wrote up on using atkinson dither as a creative effect. There's #janet sample code, along with links to the actual implementation in C (via #weewiki HTML export).

https://pbat.ch/proj/monolith/wiki/dither_1bit/

All of the bits of #monolith written using #worgle have been HTMLized using #weewiki and #worgmap. The top-level entry point can be found here: https://pbat.ch/proj/monolith/program/

#literateprogramming

Created a dynamically generated keywords page in my static #wiki using an unholy combination of #SQLite, #Janet, #awk, and a new keyscraper feature in #weewiki: https://pbat.ch/wiki/keywords/

Well, it seems like I managed to automatically weave all of the literate programming parts of #monolith into a #weewiki! It's not all that helpful yet, due to the fact that pages have auto-generated names like "wm_000_0002". A table of contents comes next...

After that, comes the cool bits.

wiki integration: write wiki pages + documentation that can reference or link to parts of the program. Seamlessly go from high-level concepts to low-level code.

Dynamic Section name resolution. You give it a unique section name, it will generate the correct page link + location to jump to.

Metapages. Generate alternate views and maps of a program . For example: instead of viewing the program in literate form, view it as a tree of named code blocks, with each code block having a page showing where it is in the source code (line numbers + filenames are stored in metadata).

Dynamically generated indexes of various sorts.

Various insights, charts, and statistics. All the metadata is represented in a handful of tables in #SQLite. And with #weewiki and #Janet, I imagine there's a lot that could be done.

Slowly making progress with an emacs-free solution to HTML export of literate programs written in Org.

The solution? Export the program to #weewiki, my personal wiki engine. It already has a hand-rolled org markup parser, suitable enough for the subset of org that I use.

Okay, this could be actually horrible, but I managed to embed dynamically generated #btprnt images into html documents via my #weewiki engine:

btprnt draws something to a buffer

buffer gets converted to an RGB buffer

RGB buffer gets converted to in-memory PNG via lodepng.

PNG gets converted to base64.

base64 gets inserted into HTML.

All this happens inside of a native #Janet plugin, which can be called inside of janet code inside of weewiki markup (which looks an awful lot like #org

Hoping this will be helpful as I begin to wrangle up some organically grown free-range documentation for #monolith.

The software/mess I've made for myself is actually working out pretty nicely.

I'm managing collections inside of #weewiki, using #fossil scm to keep track of files. All code is written in #org-mode document, which is also the markdown used in #weewiki. Blocks of code can be thrown to a #monolith REPL for a live coding environment. Code can be tangled into a single scheme file using #worgle. Everything can collapse into a single SQLite file.

Now that I have a few helper scripts in place, the whole process feels very fluid.