it took so long to get this dockable panel resize logic working in &half-edge good lord!! I really wanted children to be able to "push" out to parents when something hits a minimum size, which turned out really complex. I did end up solving it though, and the final recursive function actually turned out pretty cute and readable!

I started working on my Japanese vocab learning app &tokacard again for the first time since the jam in September. It's evolved quite a bit - we have a loading screen, a stats page, a settings page, and a reworked data/save format that supports adding other learning tracks (types of quizzes). I'm still settling on what the aesthetic of the app will be, so it's a bit disparate, but overall it's coming together quite nicely. Best of all, I can actually use it while I improve upon it!

I've been adding window/panel docking to &half-edge, and I had to figure out the problem of "which side would you expect a panel to dock, given every potential drop point in the target panel?", which was way harder to get right than I thought!

I started out with a simple "distance from edge" solution, and then I tried a "normalized distance from edge", and then a few more others, but they had problems of feeling either too sticky or too unresponsive. I thought about it some more and now I have a continuous variant that handles both borders and some heuristics in the middle for what people likely expect c: gonna try it out now!

Got both step-into and step-over working in my &assembler project

I’ve been working a bit more on my &AR system since the jam and I now have the ability to edit the programs attached to tags! Finally I can fix that stupid bug in my tic-tac-toe game (without recompiling and relaunching my server like during the jam).

the literal actual very first exported model from &half-edge, has been successfully opened in 3D printing software!! u did so well hi.stl :tired: :acegikHeartShape:

I've been nooding away on tabs in &half-edge, so that you can open multiple scenes (this is very rare in 3D modeling tools for some reason)! this time making them actually functional, with editor/viewport/selection state on a per-scene basis rather than as global singletons

My assembler can now open and read a file
Just a matter of time until I can write something useful with it

&assembler

implemented half-edge box selection in &half-edge !

&perspective-drawing Oh god, position becomes rotation in curvilinear. Also, implemented rudimentary curvilinear edge drawing.

I've done so many boring backend plumbing things with &half-edge of late so the only visually interesting thing I have done is having implemented camera zoom :pensivebread:

&perspective-drawing Added the construction lines for subdivison because it's usually important to know where the center of the cube is.

been experimenting with making a tabbed interface for &half-edge ! It's just the UI right now, but this is one of those things that would make it feel a lot more modern compared to the big established modeling tools, where every time you want to open a new model, you have to decide whether to save or discard whatever you already have open. tabs like this would let you work much more fluently in terms of UX, something I'm prioritizing a lot with this tool!

Here is a short demo of it running an unfinished snake clone.

iterated a little more on the &half-edge logo! I kinda like this one!

&perspective-drawing Added a "Analysis" window that compensates for position, distance and tilt so you can analyse how each parameter effects the cube more accurately. (Sorry, it doesn't actually do the analysis for you. (Yet?))

got the standalone build of &half-edge looking fancy with a custom titlebar!! i had to go to win32 hell and back as some of you might've seen in #workspace, to support all the windows features, but it finally works well :SCWblushHEART:

okay I know using unity's UI system is like, the opposite vibe of handmade, but I'm really happy with the progress setting up the UI for &half-edge :heart_cat:
I finally tried their UITK, and it's actually pretty dang nice so far! It's very web-like, for better or worse, but it made me jump into that quick iteration web dev mode where you can just refresh and immediately see changes, which, I didn't think they'd pull off! maybe I had low expectations but, so far it's been nice! The big thing that remains to be seen is how well I can capture input and add all my custom handles into this, since all of that was done with the legacy IMGUI. ~~and also figuring out how to hook into win32 APIs from C# to get borderless windowed with proper resize controls and drop shadow when not full screen and all that which I'm not looking forward to :SCWWcrying: ~~

&afforixbox
Hello y’all.
Inspired by Dynamicland and gaming systems (like my DS), I implemented a cartridge system into the box. Pretty cool in my opinion!

Share the files with &screen-buddy - now you can simply drag&drop file on remote screen to upload it to the remote computer
https://github.com/mmozeiko/ScreenBuddy/

got trackball rotation for the rotation gizmo in &half-edge working now! lots of quaternion math today, which was fun!

there are a few things that made this an interesting case to implement:

1. all my handles cache the initial state when you start dragging, and then only add a delta. this is useful to prevent the kind of drifting/precision loss you sometimes see in certain gizmos when you only ever apply a per-frame delta, which will accumulate error. unreal's rotation gizmo had this issue, for example
2. in this case, unlike the per-axis rotation, I still do need a cumulative delta

given these constraints, there were lots of space transformation with quaternions I had to do which was kind fun to brush up on and finally grok more properly, so I wrote down some quaternion notes which might be useful to others too! my solution was basically:

• on start drag, cache the current world space quaternion rotation w
• the mouse pixel delta is divided by the radius (in pixels) of the gizmo, which makes it so that the distance you move the cursor, also corresponds to the radians you want to rotate by, thanks to radians being 1:1 with arc length (yay radians :heart_cat: )
• the magnitude of this scaled delta is the angle, and the axis of rotation is a perpendicular vector to this direction, which is a simple (-y,x) or (y,-x) swizzle
• from this, we can construct a quaternion representing a per-frame delta rotation, as a camera space quaternion
• this is then accumulated in another camera space quaternion, by composition delta = frameDelta * delta, the order here ensuring delta is applied in the extrinsic space (swapping them would apply the rotation in the frameDelta's own intrinsic axes, which is, not what we want)
• then, in order to calculate the final rotation, we need to transform our camera space rotation delta, and apply it to a world space rotation. In other words, we want to transform the delta rotation as an intrinsic rotation applied to the camera's rotation c, but as an extrinsic (world space) rotation.
• I did a bunch of math today, and basically it ends up being
  c * delta * c.conjugate(), which, as applied to our initial cached world space starting orientation w, we get
  c * delta * c.conjugate() * w, aaaand then it works!

thanks for coming to my ted talk :henlo:

got the rotation gizmo for &half-edge functional now! it uh, was a little broken bc I forgot to normalize a vector but now it's working c:

&clock Big thing for today is Today's Schedule.

Relative time is good and all, but it's not very useful for telling somebody else what's on my calendar.

Also, more work on streamer-mode calendar-viewing :P

I finally published my end of jam writeup about &babbler here: https://forkingpaths.dev/posts/24-10-02/wheel_reinvention_jam_writeup.html
I explain the motivations of the project, how it works, how it differs from the wheel it's trying to reinvent, what insights I got from it and the new questions it raised.

&dragonfly
I added the Inspector tool! I needed a way to debug the rendering of the web pages. I have a lot of problems with the margin and padding.
Now, it's easy to have the value and to understand that's happening?
There's also a responsive mode. I can set the viewport size and flip it.
Last thing, the inspector tool can manipulate the DOM and duplicate remove nodes

Added rotation to objects, finally, so now I can actually use the third dimension properly. &ar

&clock Finally working well enough that I can auto-ingest most of my calendars, and get all my events in.
Tomorrow is apparently slammed. yay.

My final demo video for my AR jam project, inspired by Dynamicland. This system allows you to build apps that are a natural part of your physical space, anchored to real physical objects. The apps can be stored inside QR codes and can be copied from tag to tag for easy collaboration.

The apps are collaborative by nature, and the physical tracking codes allow anyone to participate and collaborate. My hope is to extend this system and use it with my robotics students this year. &ar

I finally got a bit more time to actually write out part of the description of &ctrpg , and I'll probably have time to finish the rest tomorrow. As for the program itself: I managed to get this simple dynamic background done, which is pretty neat! Hopefully I'll find more time for the rest of it soon, at least enough to finish the basic demo I wanted to get done last week.

If you're wondering how this relates at all to tabletop character sheets, the short version is that the character sheet is really just something to render; it's the rendering I'm really interested in.

&dragonfly
I'm adding the HTML inspector in my browser!

The final demo slide for &active-slides is done. And that's a wrap for my jam project. Originally my idea was to have an actual editor for slides but I didn't really get enough time this week to finish something like that. so I just decided to see how easily I could make slides with many dynamic elements using the project

&crispyfont I went a bit farther down the path of generating sizes from a single glyph definition, but the code is kind of a mess. I may work on this idea more, but I enjoy drawing the atlases more, so I went back to that and drew a 12px size to finish out the jam. Not sure I made anything useful, but I had fun 😁

Final update for the jam.

• Added ability to save and open files

I finished my flashcard app prototype, &tokacard tonight! There's still a lot that needs to be done, but today I added a main menu, an about page and navigation between each screen. Additionally, I added little touches here and there (an app icon, different pointer cursors, and an "I don't know" button) and managed to export to a release jar file. There's still a lot to be done before this is 'usable' in the long term sense, but it feels really good to have this finished, and I learned a lot about Jetpack/Jetbrains Compose along the way!

&aabb level editor, made a lot of progress during the last day:

• added camera controls: normal mouse rotation and orbit around the cursor
• more customization: camera input sensitivity, grid colors, grid alpha, grid fade distance, clear color etc.
• Ability to create and select/deselect brushes
• import textures and generate texture array
• Assign textures to all faces / only the selected face of a brush

If there was more time I'd tackle:

• Rendering is messy, I would combine each renderer into one draw call and write to a big buffer
• TexCoords editing and maybe a toggle to switch between world space uvs and texcoords
• deform aabbs with planes (similar to boolean operations)

All in all I am quite happy with the results, considering I only spent 3-4 days, learned a lot about odin and really like the language so far.
Thanks for organizing the jam and good rest everyone! 👋

&luggen-astro
7th and final day of the Wheel Reinvention Jam 2024.

Most of the day was spent on memory allocation and introducing more particles.
The particle allocator (linked free-list) was fragmenting a lot so I ended up re-implementing most of it.

Particles was the main goal of the day. I had difficulties coming up with a scheme that allowed parenting emitters to ships (trail effect). In the end I just wrote something that works without introducing any entity systems or what have you, which I'm glad for.

Somewhere around midnight I realized that packing the emitter array was causing bugs due to them now being referenced by "entities", so I had to implement a pool allocator. The packed array is still in use for iteration purposes but now it's an array of pointers to the pool data.

Green blocks show available particle memory. Orange blocks show available emitters.

What can I say? This jam was great. I feel like I've passed some sort of milestone. Big thanks to the Handmade team for organizing this! While I didn't quite reach my my goal of making a complete game loop I now have a foundation to work from. And some parts of the code will see their way into other projects.
It's almost 4 am now. Good night!

&drawn-comments the images get saved as descriptions inside comments so that their positions don't get too messed up when editing the files with other text editors.

&makec A simple C/C++ build system written in C that uses C as a project specification language
https://handmade.network/p/629/makec/
https://github.com/UnNabbo/MakeC

&pureforms
With the jam project coming to a close, we created the first PureForms app and what may very well be the worst reinvention of a wheel ever: A color picker that only works in increments of 16 and doesn't even give you the RGB value of the color you've created. But it does show you pretty tool tips, badger you about closing it, and take up only ~150 LOC. Be sure to check out PureForms in its entirety at https://github.com/errorsuccessdev/PureForms. I've also written up an overview of what this project is and what it's for over at https://handmade.network/p/592/pureforms/. I plan to continue working on this library post-jam, so if easy Win32 GUI dev is appealing to you, keep an eye out!
https://i.imgur.com/uNtPskz.gif

&bin-dash Finaly Jam Day:

For the last few days I've been playing with the arrangement of the interface. Finally ending with a permanent hex view that can be viewed side by side with higher level data tables. Ranges of the file are marked up by the parser, so that the user can jump to them in the hex and view a higher level data tables associated with the section if one happens to exist.

Based on the results of this jam I see a lot of potential in a tool like this to visualize all kinds of binary files not just PE/COFF files. I expect to continue development on this to take it a lot farther.

&crispyfont Starting to auto-generate sizes from code now - I'd like to create a visual editor eventually, but for now I'm typing in values manually to test the rasterization code

Last one: a stopwatch (kindof) in &babbler.

Latency measurement for &screen-buddy
Running at 30 frames per second (currently hardcoded) it captures laptop screen, encodes it as video, encrypts and sends packets. Then on desktop it receives, decrypts, decodes and renders video - just with 1 frame latency so only ~33msec (assuming you have good internet connection)

ScreenBuddy - simplest way for remote desktop screen sharing over Internet: https://github.com/mmozeiko/ScreenBuddy

• privacy friendly - no accounts, no registration, no telemetry
• simple to use - no network configuration needed, works across NAT's
• secure - all data in transit is end-to-end encrypted
• efficient - uses GPU accelerated video encoder & decoder for minimal CPU usage
• lightweight - native code application, uses very small amount of memory
• small - zero external dependencies, only default Windows libraries are used

&screen-buddy

Full demo coming soon… &ar

a typical reencoding graph in &ffmpegraph

got linear drag actions in c: &half-edge

I half-hacked variables at the last minute, as demonstrated by this little counter. I think that will be all for this jam! &babbler is obviously just a tiny computing toy at this point, but it's already pretty fun to play with.

Code generation added for Go, C, JavaScript - a column that can be copy-pasted into your code producing a function to step the CPU forward based on the current instruction. There be bugs.

&perspective-drawing Opted for simple, functional, auto-generated UI and added various guidelines. Think this will be all, jamming wise.

spent some more time working on the &aabb level editor
added moving an aabb cursor on the XZ plane, face selection and face editing

finally been able to do more work on the transform gizmo for &half-edge (really bad timing on that apartment move :SCWWcrying:). I've now got basic handle mouseover detection going, and migrated the handles to be less coupled with the IMGUI loop! the things up next are:

• adding interactivity, to drag these cones for linear movement
• adding the lines for the arrows, so it's not just arrowheads
• adding planar handles for xy/yz/zx movement, and their interactions
• optionally adding modifiers like precision movement, as well as camera-plane dragging!

Logic gates implemented in &babbler

&active-slides
Putting together a small demonstration was fun! My test slides now include implementation of LERP as well as BILERP. That'll probably be it for the jam project, but there's loads more I could add. I just didn't get as much time this week as I had initially hoped.
The bilerp slide fits in 120 lines of lua code, to be expected since there's actual interactivity in this

&crispyfont I spent too long figuring this out, but I finally got resizing and zoom working the way I want. By default zooming in the browser just scales everything up uniformly and gets blurry, but I wanted some elements to stay the same while some other text changes size. I only have 3 sizes of font currently, but it picks the one that's closest to the target size for the selected zoom (or a multiple of one of the sizes). That way it should stay aligned to the device pixels and look sharp. It's mostly working, so next step is to create some more font sizes

Forgot to post an update yesterday -- Here is what was added.

• Backspace
• Multiple windows
• Focus management
• Syntax highlighting
• Line numbers

Simple vocab flashcard scheduling for &tokacard. There's lots to be desired, but it works! The fact that you can in theory learn from it in a state as simple as this is nice to see.

I've just completed the "session scheduler", which schedules the order of cards in the current review session. For pseudocode, it looks a bit like this:

fun schedule(card, wasCorrect) {
  if (!wasCorrect) {
    studyQueue.add(1, card) // Wrong answer, re-schedule it after the next card
    streaks[card] = 0
  } else {
    if (card !in streaks) {
      return // We got the card correct first try! No more reviews needed
    }
    if (streaks[card] + 1 >= 3) {
      return // We got the answer right three times in a row! No more reviewing it
    }
    studyQueue.add(2 + streaks[card] * 2, card)
    streaks[card] += 1
  }
}

As you can see, answering a card wrong will re-schedule it again immediately after the next card. Answering correctly will push your next review out further, with each correct answer pushing your review time further down the list. Three correct reviews in a row will "finish" a card for that review session.

Now that short term (single review session) card scheduling is finished, next up is to figure out, for each card, how far in the future we should schedule it's next scheduled review. I'm thinking about implementing a modified version of the Leitner system for this!

&ffmpegraph is generating valid ffmpeg commands

&luggen-astro
Day Six.
Made quite some progress today. I ditched the scene hierarchy since I realized I could do deferred removal with packed arrays anyway as long as I sort the indices (or pointers in my case).
The main feature of the day was code compression, introducing callbacks and making "entities" data driven so that now, for instance, emitters can run different particle "systems" based on profile selection.
And finally, enemies can now shoot and kill the player. It's almost starting to look like a game!

I can run multiple apps at once now. &ar

&how-dwarf-works This is a pretty long post that gets in to a lot of detail on parsing the .debug_info section for ELF/DWARF binaries. As always please send me feedback/errata/questions, I love talking debuggers!

This is going to be my final post for the jam, thanks for putting this on, it was a lot of fun to buckle down and make some forward progress on a project, then actually share it! ❣️

https://www.calabro.io/dwarf/die

Today I added a first spatial query to &babbler. You can detect if a card p points at another card q in a given direction d with a query of the form (when p points d at q). p, q, d can also be placeholders so you can react to several spatial relationships at once. The query itself triggers the drawing of "pointing whiskers" so you can visualize how cards point to each other.
Since it's impractical to precompute all possible spatial relationships, I introduced a notion of "responders" to the facts database, ie callbacks that can generate new facts on demand when a query matches a specific pattern. Next step is to add new spatial responders (ie proximity, clustering, etc) and hopefully allow such responders to be defined in user-code.

&afforixbox
I did some upgrades to the box this morning. The window management is cleaner and it supports more windows in total.

The rest of my update is a reflection of sorts. I learned something interesting. It’s important to use precise language to talk about what you need. I discovered that there is an existing classification of tools characterized by a set of features that I care about. Specifically, a subset of the features of the box actually constitute an “automatic tiling window manager”. Once I had this language, Google landed me on an existing tool (komorebi) that meets the features and more! Unfortunately, the license is not permissive and it has a large footprint anyways. For now, the box integrates with an existing installation of komorebi to get the job done

&dragonfly
Doesn't look big but my browser can now render form!

&active-slides
Finally able to show the interactivity in one of these slides. Dragging around objects, and super easy to program in lua!
The small test is also running at ~0.7 millisecond frame times, (2x better than my previous attempt at an ui engine). Ofcourse the test doesn't really mean anything big about the performance since it's such a small demo, but it's nice to see I'm doing something better than last time, at least for myself.

The greatest AR app you’ve ever seen. &ar

(The actually interesting part begins now.)

&ffmpegraph
started a bit late because life got in the way, but I got functioning node connection and traversal working
now time to actually issue ffmpeg commands

i'm super late to the party, for me it's day one, started working on an &aabb level editor to learn odin, so far there's a window and a grid and i'm having a lot of fun getting into the language

&pureforms
This morning we knocked out event handlers and added my correctly positioned™️ tooltips! PureForms allows you to create this GUI and receive click/hover/close events in ~100 LOC:
https://i.imgur.com/SXTpOSy.gif
The full code is available on my GitHub at https://github.com/errorsuccessdev/PureForms.

&luggen-astro
Day five.
Implemented a scene-hierarchy of sorts. Currently only used as a linked list for enemies since I needed to defer their deletion. Other types of entities are still in packed arrays but I anticipate at least some of them having to be part of the hierarchy eventually.
On a more fun note, the game now has particles! I'm going with the usual emitter-object scheme. Each emitter is assigned a buffer of packed particles of variable size, for which I had to write a new allocator. In general I'm sticking to arenas whenever possible.

I do get the DM. My post is tagged with &pureforms at the top...

Reproducing a small DynamicLand tutorial in &babbler! This shows the use of claim, when and wish clauses, how to apply illuminations to the cards, and how to use placeholders in when clauses to match several claims.

&perspective-drawing
Damn, I didn't know 1 Point Perspective could do this.

&perspective-drawing
Joining the Jam very late but wanted to make a little something to help me learn perspective drawing. Now I have working construction (and parallel) lines, next will be adding UI to tweak all the parameters on the fly.

First status update.
Some basic text editing features. Building an IDE is harder than I thought, might end up with a text editor lol.

Backspace, enter and key repetition evidently not working:

&afforixbox
still really basic and lots of of rough around the edges functionality, but the box manages window layout now.

Finally! I have a little Lua app running on a server, rendering scene data which is sent to my phone over websockets, which is then being tracked to this tag. Should be able to build out actual AR tic-tac-toe now. &ar

&easy-file-transfer
My first status update, though I have been working on it when I could since Monday.

The premise of this program is to try to make it easy and secure to just send some files to someone. Alice wants to send files to Bob. Bob runs the program in receive mode which spits out a code. Then he sends the code to Alice who then runs the program in send mode, passing the code and the files she wants to send. That's about it.

The architecture has a sender, receiver, and broker model where the sender and receiver both connect to a central "broker" via port 443 to communicate. The main purpose of this to get around the issues of P2P like blocked ports.

I originally wanted to have a GUI using the imgui lib i made for BoksOS and spent some time getting that working. But took me an embarrassingly long time to realize I didn't have copy/paste working and felt it would take too long to get that working, so I abandoned that and started on a CLI version. Hope to do a GUI one day!

The screenshots are what I have so far.

A bit of a detour from the fun &AR stuff into making the server that will actually run these little AR apps...I have spent far too long wrangling Lua but it is working.

&luggen-astro
Day four.
I required circles for debugging purposes so I went a ahead and implemented my very first sine and cosine functions. I don't know how the pros do it, but I wrote a program that generates a lookup-table spanning one quadrant of the unit circle. Then the functions themselves are just converting the supplied scalar to an index, and determines the sign of the value being read.
After that, refreshed my memory on the Minkowski difference and GJK algorithm. Current collision detection is just basic circle overlap test without taking movement into account.
https://caseymuratori.com/blog_0003

&bin-dash Day 4: It's not much yet - but I've started making steps to add another type of view to Bin-Dash. This one will map markup about the file onto the hex (and maybe later something like a zoomed out mini-map). To get started I setup a rough sketch for this type of visualization as a split with a list of the markups and a hex view. The markups I have so far are actually diagnostics for malformed inputs. I hope to combine these markups with markups like ranges of headers, sections, etc. so that the visualizer can be used to diagnose and fix issues with binary generators.

Func facts! Not much progress today, but we're now registering claim clauses to a "facts" database, and matching when clauses with existing facts &babbler.

&afforixbox
small update today ... the software side is coming along for the box (support is written for open/close/tracking of windows) ... it's easy to see that I don't care about graphics yet 🙂

Finished almost all the lua bindings for &active-slides and also implemented switching between slides! Smoothely

&crispyfont Day 3 - I got a pipeline setup where I draw the font in Aseprite aligned to a grid, export a png, and then generate the packed atlas + font metrics with a script. I've chosen to only use fully transparent or fully opaque pixels for maximum crispness... the upside is a bit-depth of 1, but the downside is that curves look real bad, so I'm going with a more angular design. 3 sizes so far:

&playout Day 3 - After successfully ignoring several additional warts discovered in my GUI layer, I implemented what could be called an MVP for a room layout tool - I can add, remove, scale, rotate, and name objects, so technically I could actually use this to lay out a room! As I'm fond of saying, "It may not be viable, but it sure is minimum"

&luggen-astro
Third day of Wheel Reinvention Jam 2024.
Besides addressing some bugs in the shader code generator, most of the day I've been slowly building up the game state update routine and rendering pipeline. Entities are all instanced in one draw call. I was intending on textured quads but the triangles will have to do for now. The next major issue is going to be collision detection.

Did you know you can use a Poisson solver to solve for field lines on an arbitrary distribution?
Field lines 'follow the flow', and they are super useful for visualizing flow fields or charge distributions
&pps

&how-dwarf-works The new site is live, along with the series introduction, the first meaty post on parsing ELF files, and an appendix for code samples! Let me know if you're having issues, I just deployed it a minute ago. Please also reach out with errata, questions, clarifications, etc. 😄

Next post starts on parsing actual DWARF info (we're going to parse DIEs and related info first)

https://calabro.io

Namespaces are now collapsible

&assembler

&clock Got a small amount of ical parsed, and set up a little task rules system for everything else

&playout Day 2 - 1 hour of implementing Open and Save, 3.5 hours of ✨surprise major refactoring✨ after realizing my GUI system didn't handle tree modifications properly (e.g. adding/removing the [MODIFIED] tag at the bottom)

&dragonfly
I added a better support for the images. Just need to add some caching mecanism

&bin-dash Day 2: I've moved the section table parser to the abstracted pe.parse layer, and then constructed it within the Bin-Dash UI data structure. Then I decided I wanted to move the table like interface into a separate data structure from the high level hierarchy of parsed features, which led to some major reconstruction of the UI data structures. This new interface structure feels more appropriate and simplifies some problems that were going to be tricky when trying to do the whole thing in a single uniform structure.

Not a lot of super cool pictures that actually mean anything for day 2 of &pps, but I've implemented 'my' algorithm (which I've taken to calling the 'kernel solver') for the CPU (for now), and I was surprised to learn that, when compiled with odin's optimizer, it was actually faster, as well as more efficient, than Successive Overrelaxation
That bodes well!
A lot more characterizing and visualisations have to be done though

&luggen-astro
Second day of Wheel Reinvention Jam 2024.
Spent most of the day implementing the shader code generator, since I use my own flavor of glsl and also require include preprocessing.
After that I kept adding to the OpenGL wrapper and now I finally got the "hello world" triangle!
From here on I expect progress to ramp up.

&babbler is a little experiment based on my misunderstanding of DynamicLand's Realtalk. Here's a a first jab at the UI, where you can put cards on a canvas and write code on them. Got immediately sidetracked into writing a little structure editor for the cards...

drawing some gibberish images inside a text editor, the basic idea works 🙂 &drawn-comments

&pureforms
Not much of an update today as I spent the morning prepping for and doing a job interview (which I think went well 🤞). I did, however, rough in a way for us to keep track of all the buttons. What could possibly go wrong?

typedef struct structPrivateButtonList 
{
    Button* button;
    struct structPrivateButtonList* next;
} private_ButtonList;

// ...

void private_addButtonToList(Button* button)
{
    private_ButtonList* newListEnd = (private_ButtonList*) HeapAlloc(
        GetProcessHeap(),
        HEAP_ZERO_MEMORY,
        sizeof(private_ButtonList)
    );
    assert(newListEnd);
    newListEnd->button = button;
    newListEnd->next = NULL;
    if (global_firstButton == NULL)
    {
        global_firstButton = newListEnd;
    }
    else
    {
        private_ButtonList* listEnd = global_firstButton;
        while (listEnd->next != NULL)
        {
            listEnd = listEnd->next;
        }
        listEnd->next = newListEnd;
    }
}

&active-slides Starting with my "Interactive Slideshow Program" project. Off to quite a late start, but I've finally got a few lua bindings for drawing UI things. Lua will be the way to specify slides, and as it's an actual programming language, interactivity should be quite easy to write

I haven't posted an update in a while, but since my project in on topic with the jam, here is how my assembler looks like today, sped up x2, so you wouldn't have to watch me thinking through the instructions.
The first thing in this clip is me creating a new namespace, which is the newest feature I have just implemented.

&assembler

&afforixbox
I’m a little late to the party :). For the wheel reinvention jam, I’m working on Afforix Box. It’s a fresh take on the PC human interface; my aim is to replace the windows desktop/shell (explorer.exe). Afforix Box is a hardware(arduino)+software solution!

I'm gonna make a transform gizmo for my 3D modeling tool (tentatively called &half-edge ) for wheel reinvention jam! as with most things in life, it always starts with working out the math for intersection testing a cone in the fragment shader of a quad

&clock mini mode / power saving when out-of-focus, so I can run it in the background while I'm doing work this week.

yay, I got it displaying &AR content attached to an AprilTag 😃

&playout
First day of the jam - Playout is a room layout editor, like when you use graph paper and little labeled cutouts to plan where you're going to put the furniture in your room. Today I set up a new repo with a prebuilt platform/graphics layer, and a custom GUI system I made beforehand. I've got some basic stuff done: draw a grid, pan/zoom, move rectangles around. More to come!

Here's a very informal blog post I wrote to start off the jam for my &modern-urls project. Don't expect too much from it, but if you have a bit of time and find the topic interesting feel free to give it a read https://www.siltutorials.com/blog/the-url-problem
(Reposting because I got the & mention wrong, and editing the post didn't seem to work)

One way to solve this problem is to give every computer in the world a unique identifier. In this hypothetical past, when there were only 10 computers, we could just label each computer with a number 1, 2, 3, etc. and then we could use that number to uniquely talk about each computer. Maybe my friend owns computer 3, he tells me his computer is 3, and on my computer which is 4, I say I want to connect to computer 3. So my computer looks at every computer connected to it and finds the one that reports itself as computer 3. This is pretty simple, and actually would work great if it weren't for a few fundamental problems:

1. There are more than 10 computers in a world. Way too many for a human brain to remember each unique number. Too many for my computer to ask every other connected computer what number it is as it tries to find a particular computer.
2. Humans are not as good at remembering "random" series of numbers as they are at remembering names and words in their own language. I can remember 10 random English words easier than I can 10 random numbers between 0-255, and that's not a fair comparison, because there are more English words than 255. Also some names are more valuable than others, because they are easier to remember, or represent more popular concepts. For example more people may want their computer to be named #1 rather than #2425, because #1 is easier to remember and people have a preference for being #1 in a competitive sense.
3. People all speak different languages, and it's easier to remember words and names in the language(s) you know. This is especially complex if my friend and I speak different languages. His computer might have a name in his language that is hard for me to remember. We need some system where we can use a translation of his name into a name that I can understand and remember.
4. Say my friend buys a new computer between telling me about the game and me trying to download it. This new computer might have a different number than his old one, but it's still **his** computer, and he likely means for me to get the game from his **new** computer rather than his old one. It would be nice if he could tell the world "I got a new computer. Please use computer 9 now, not computer 3" without having to communicate with me specifically.
5. Files and information transfer hold value, so someone might want to pretend to be my friend's computer. How can I be sure I got my friends file, not someone else who tried to pretend to be my friend? I somehow need some guarantees that the information my friend told me is enough to confidently route me to his computer, not someone else's.
6. The file on my friends computer might be in some folder. Once I'm connected to his computer, how do I find the file I am looking for? This is sort of a sub-problem, since my friend could include the information about which folder it's in as he's telling me the ID of his computer, but we'll likely want to treat this as a sub-problem, since it's likely easier to solve the problem of finding the right file **after** we solve the problem of connecting to the correct computer.
7. There might be a **lot** of people that want this file. Maybe my "friend" is actually Taylor Swift, and the "game" is actually a new album she just finished. Millions of people want to download this album but a single computer is not powerful enough to serve all of those people at the exact same time. For a variety of hardware reasons, we can't have a single physical computer that everyone is downloading from. We need to set up a system where the load of transferring the file is distributed amongst a collection of computers that all have the file. Even if everyone is finding the file using the same information that Taylor told them.
8. Related to #6 Each individual computer may break, or it may go offline for one reason or another. We can't have one computer failure cause the entire system to be inaccessible. We need to have a dynamic system where people get routed to a different computer when the one they were trying to connect to is unavailable
9. People live all over the world, and downloading a file from France while I live in Canada is not always that fast. It would be nice if my friend could manage a computer that is not physically located at his house, so that people that he can share files quickly with people who do not live close to him.

The URL Problem

Here's my description of the URL problem, as I understand it (i.e. I haven't done any research into the topic, this is the story I tell myself in my head. I'm sure the reality and history is a lot more complex)

Let's imagine we are at the beginning of the internet. There are like 10 computers connected to each other. If I am using one computer, and I want a file on another computer, I need to somehow distinguish which of the other 9 computers I want to access to get the file. There are essentially two problems that need to get resolved
* I need to know which computer the file is on. Maybe I just used the computer recently, so I want to see and remember the name of the computer I was accessing so I can tell my computer at home later which computer I am talking about. Much more commonly (in the modern world at least) I was told the file existed by some external source. Like maybe a friend told me that there's a cool game on his computer that I should try out. In this case my friend needs to somehow communicate to me the information about his computer so I can access it later
* Once I know which computer I am talking about, I need to somehow put some information into my computer and run it through some system that will get me connected to and downloading the right file. Essentially, using the information I have in my head, combined with the information and systems on my computer, I need to reliably (and hopefully without too much effort on my part) get connected to the correct computer.

My jam project is an &AR workspace inspired by Dynamicland, where you can interact with little apps attached to tracking codes. Before the jam I got as far as running an AR sample app on iOS, and tracking AprilTags within an AR session. My goal now is to attach AR objects to those tags.

&bindash Day 1: Looking at symbols in an object file.

Accidentally created something that looks like sunset/dawn with &pps
Doing math visualizations is always fun because of stuff like this

&how-dwarf-works I don't have a link to share yet since it hasn't been deployed to the wild yet, but I re-did my personal blog today and wrote the first post in an entry in the "How DWARF Works" series. Next up is "how do you parse just enough ELF to get all the DWARF data you want"

&clock day 1-ish progress report, calendar integration is up next. (repost)

&luggen-astro
First day of Wheel Reinvention Jam 2024.
So far I've only got the barest minimum to get a window with OpenGL context going, along with string formatting and other utilities. I decided to start completely from nothing, using previous code only as reference.

&techmates
I got a basic rectangle overlaying over the screen with SDL2 and parsing an INI file.

These are the results of a simple Poisson solver benchmark (I made some reference implementations to compare against), and I'm working on some colourmaps
Currently manually inputting colour values in the code, which is a little janky
Hoping to switch to OKLAB at some point too, instead of lerping rgb hahaha
&pps

&pureforms
We are off to a great start! This code + PureForms magic is all it takes to create the window (or "form") shown in the screenshot. The repo is already on github here if you'd like to take a peek behind the scenes: https://github.com/errorsuccessdev/PureForms

#include "PureForms.h"

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ PWSTR args,
    _In_ int showCommand
)
{
    Form* frmMain = createForm(
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        L"My Form"
    );
    assert(frmMain != NULL);

    Button* btnFirst = createButton(
        10,
        10,
        200,
        30,
        L"Click me!"
    );

    Button* btnSecond = createButton(
        10,
        50,
        200,
        30,
        L"No, click me instead!"
    );

    bool result = showForm(frmMain, showCommand);
    assert(result);
}```

&clock Starting work on my jam entry a little early, because I'm not going to have a ton of time this week