December Adventure 2025 Log

Day 1

Worked on getting my nova parser in a presentable state so I can start work on actually compiling some nova code to a VM or binary representation.

The code is here: Taenite

Also set up my december adventure page.

Day 2

Today I spent a lot of time working on cleaning up my system and setting it up so I can load my personal OS setup on other computers from a USB drive. I’m planning on next stripping down the kernel on my various devices and then just having a generic kernel on usb.

Also worked on planning out some optimisations for doing Nova codegen around not generating full tuples when it isn’t necessary for disambiguation.

Day 3

Spent some time today researching and setting up the nouveau mastodon server to be a little more resilient to getting boosted by big accounts. Mostly increasing a few of the threadcounts so that more things can get processed at once.

Also started work on the “compression” for converting nova code to quasar. So far just some basic stuff and a whole bunch of comments of things that need to be implemented to make it actually work.

Day 4

Not much coding today, spent most of my time doing yardwork instead. Got a little bit done cleaning up my NixOS config so I can have a bunch of individual modules for services with options instead of one giant config.

Skipped Day 5

Day 6

Did some more work on organizing my nixos configuration. Lots of open firewall ports that were just sitting around in a big array with no indication of what they were for. They were all used but needed to be organized.

Continuing to do more nova compiler stuff, baking rulesets into a nice intermediate representation that I can either run or compile. Getting all the special syntax features compiled out so its just very basic rules with variables. Next I’m going to start generating C code from it.

Day 7

Came up with some new ideas for nova compilation, I don’t need a seperate stack to keep track of what the arity of facts is for compiling to quasar which doesn’t have tuples. I can just put the arity on top of the stack after pushing a tuple and it basically becomes a “type” for the tuple.

Also started a new page on my site for various system management things that I often have to look up so that I can have them all in one place for the future.

Day 8

Got converting facts to quasar instructions working. Had to extend the parser to support strings so that I could use more test programs. The next step is actually compiling rules which will be a little harder since I have to care about stack depths for looking at multiple elements at the top of the same stack.

Also worked on design ideas for redoing my site. I’m thinking of doing something like my own spin on the old blogspot style with a big column for stuff in the middle and links down the sides.

Day 9

I can now compile full nova rules to quasar. Still missing the parentheses syntax to do stringy DSLs so one or two of my test programs don’t work, but basic ones do. Once the parsed data was in the right arrangement it was really easy to just iterate through it and output the bytecode. Next comes improving the parser to support some of the more nice QoL syntax stuff and actually executing/compiling the bytecode.

Day 10

Finished the initial interpreter. It can run basic programs with variables and no reliance on IO. The next step is to implement some IO operations so that I can actually do things with it. Then it will be time to write code to compile quasar instructions to other languages instead of interpreting it.

Day 13

Missed a couple days but I’m back with a passion. Today I got IO working, currently its a table of functions that the interpreter can call out to as coprocessors, but they will eventually need internal state so they’ll be structs that can be interacted with through a trait when the VM needs to use them. The way they are implemented means that technically things can be pushed onto the stack in the rule that fires the coprocessor in bytecode as well, though that may not end up actually being useful for anything.

Day 14

Added numbers to the parsing, now its possible to embed a number directly in the nova program rather than a symbol representing a number (useful for not having to intern every possible number for characters). Also added the ability to dump the quasar assembly to disk to be compiled or run seperately. Found a little bug in the code generation where elements got put onto stacks in the reverse order they should be. Still need to write code to read the quasar assembly back in to be run.

Day 15

Added more debugging information to the interpreter. It can now print out the state of stacks in between steps. This revealed some really odd bugs that I introduced while adding some of the new parsing code yesterday. Mostly off-by-one errors in push and pop.

Day 16

Compiling to C is working now. So much cleanup and improvements to do, but pretty much all of the main base features I wanted to have working are present in some form. Now to start on optimisation, and making it easier to add in new builtins. I’ve done some work today on designing that so that it will work both for the C compiled version and the interpreted version without having to duplicate too much stuff to have to update when I make changes.

Day 17

Added embedding C code into rules as an option. It very minorly adds some extra stuff to rules for the interpreted version since there will be an extra copy of any rules builtin to the interpreter that won’t fire, but for now its good enough to get things working. The C code goes on a stack that is labeled with “@c”. So it will be easy to extend for whatever other languages I want to compile to. Tomorrow comes a lot of cleanup to actually make things nice to use.