!til here's part two of my learning jam project &colors where I explain gamma correction and sRGB encoding, and update the vector graphics renderer of &orca to be gamma correct
https://youtu.be/cFoi1OLHFQ0

been implementing :rxi: 's cached renderer but with compute (&sdf) instead of software rendering. Efficient & Fast!

I just finished adding GLES bindings to &orca, so I figured I could try porting my old WebGL fluid sim experiments to it, and it was very pleasingly easy: https://www.youtube.com/watch?v=NqfEtRGEdYU

@bvisness wrote a small breakout game in &orca using our vector graphics renderer! Some platform discrepancies to iron out still, but it's shown here running on windows and macos.

I added a logging API and a basic in-app console in &orca, that displays log entries emitted by the guest webassembly module. It doesn't look like much yet, but it's already a nice quality of life improvement. The entries are also structured, meaning it could later be used to filter them or to jump to the line that generated the message, set a breakpoint, etc.

As a small jam experiment, I added an overlay to &orca that shows you the source code of the webassembly module it's running, and displays colored dots next to the functions that are executed. The color itself indicates the time spent in that functions during the frame relative to the other functions of the module (ie, green = less weight, red = more weight).

I revisited the project and fixed some bugs, made a few improvement and added Markdown support for posts.
https://github.com/marciovmf/static/releases

A little bit late, but my wheel-reinvention-jam project is coming along well. &bewehr

Complete IFC (3d building file format used in the AEC industry) file reader generated from its EXPRESS description file.
I am able to render walls and slabs from the file, but not at the right location yet.
&bewehr

update Oct. 24, 2022

This diagram:

is transpiled to this JSON:

[
  [
    {
      "children": [ {"kind":"Hello", "name":"cell_7"},  {"kind":"World", "name":"cell_8"} ],
      "connections": [
	{
	  "receivers": [ {"receiver": {"component":"cell_7", "port":"stdin"}} ],
	  "senders": [ {"sender": {"component":"cell_6", "port":"stdin"}} ]
	},
	{
	  "receivers": [ {"receiver": {"component":"cell_8", "port":"stdin"}} ],
	  "senders": [ {"sender": {"component":"cell_7", "port":"stdout"}} ]
	},
	{
	  "receivers": [ {"receiver": {"component":"cell_6", "port":"stdout"}} ],
	  "senders": [ {"sender": {"component":"cell_8", "port":"stdout"}} ]
	}
      ],
      "id":"cell_6",
      "inputs": ["cell_17" ],
      "kind":"HelloWorld",
      "name":"HelloWorld",
      "outputs": ["cell_15" ],
      "synccode":""
    }
  ],
  [
    {
      "children": [],
      "connections": [],
      "id":"cell_7",
      "inputs": ["cell_12" ],
      "kind":"Hello",
      "name":"Hello",
      "outputs": ["cell_10" ],
      "synccode":""
    }
  ],
  [
    {
      "children": [],
      "connections": [],
      "id":"cell_8",
      "inputs": ["cell_11" ],
      "kind":"World",
      "name":"World",
      "outputs": ["cell_14" ],
      "synccode":""
    }
  ]
]

and the above JSON is transpiled to this Python:

from message import Message
from sender import Sender
from selfsender import SelfSender
from receiver import Receiver
from selfreceiver import SelfReceiver
from upconnect import UpConnect
from downconnect import DownConnect
from routeconnect import RouteConnect
from passthroughconnect import PassThroughConnect
from container import Container
from Hello import Hello
from World import World
class HelloWorld (Container): 
  def __init__ (self, parent, name):
    cell_7 = Hello (self, f'{name}-Hello-cell_7');
    cell_8 = World (self, f'{name}-World-cell_8');
    self._children = [cell_7,cell_8]
    self._connections = [
      DownConnect (SelfSender (self,'stdin'), Receiver (cell_7,'stdin')),
      RouteConnect (Sender (cell_7,'stdout'), Receiver (cell_8,'stdin')),
      UpConnect (Sender (cell_8,'stdout'), SelfReceiver (self,'stdout'))
      ]
    super ().__init__ (parent, name, self._children, self._connections)

and is transpiled to Common Lisp

(in-package "EH")
(defun new-HelloWorld (parent name)
  (let ((self (make-instance 'Container :parent parent :name name)))
    (let ((cell_7 (make-instance 'Hello :parent self :name (format nil "~a-~a-~a" name "Hello" "cell_7"))))
      (let ((cell_8 (make-instance 'World :parent self :name (format nil "~a-~a-~a" name "World" "cell_8"))))
	(let ((children (list cell_7 cell_8 )))
	  (let ((connections (list  
			      (make-instance 'DownConnect :sender (make-instance 'SelfSender :component self :port "stdin") :receiver (make-instance 'Receiver :component cell_7 :port "stdin")) 
			      (make-instance 'RouteConnect :sender (make-instance 'Sender :component cell_7 :port "stdout") :receiver (make-instance 'Receiver :component cell_8 :port "stdin")) 
			      (make-instance 'UpConnect :sender (make-instance 'Sender :component cell_8 :port "stdout") :receiver (make-instance 'SelfReceiver :component self :port "stdout"))  )))
	    (setf (children self) children)
	    (setf (connections self) connections)
	    self))
	))))

Wart

Branch master has a wart - a hard-coded path (see README.md). This will be fixed in branch dev.

Next Steps

Cleave ė into multiple parts

• diagram to JSON component descriptors
• JSON component descriptors to Python
• JSON component descriptors to Common Lisp

Create spin-off which enables manual creation of ė and HSM and 0D code in Python.

&abbrv 1.4 is now released:

https://github.com/jakemason/abbrv/releases/tag/v1.4

This update allows you to mark entries as "hidden" which will obfuscate their values when the application is open by replacing their values with asterisks (*) without affecting insertion functionality. This is mostly helpful for streamers who want to be sure that they don't leak API keys and alike by mistake when expanding the abbrv window.

As always, please open an issue if you run into any problems! Thanks!

&abbrv Just a quick update to these forums that I've released abbrv 1.2 which I'm considering feature complete. I'll happily fix any bugs reported by Issues or entertain the idea of additional functionality if it's requested, but unless that happens I believe the project will remain at 1.2. It meets my needs and I'm pleased with its performance for me thus far. You can see the 1.2 release here: https://github.com/jakemason/abbrv/releases/tag/v1.2

Final recap video.

On the left, the website structure. The site.txt and the Posts and themes folders. In the middle, the a portion of the source of the demo site index.html. The highlighted area displays a snipped of code that iterates all posts in order to render a links for each one of them along with their title and their creation date. It's worth noting the list is sorted by post creation date in ascending order.

A bit further, another loop iterating all "pages". Any html file in the current theme folder is considered a page and can be iterated and queried like a post.

As I said, there isn't much to a static site generator and that is why I believe this kind of tool should be simple and less bloated.

• diagram transpiler - copied das as subdirectory into project

• hw.drawio -> hw.json transpile helloworld diagram

• hwhw.drawio -> hwhw.json transpile re-architected diagram

• wart: das does not transpile simple hello.drawio diagram -> just use hw.drawio and hand-carve the generated json out of it (or just continue ignoring the issue, since hello.drawio is very, very simple and not worth any trouble)

• diagram parser: das.ohm parses output hw.json and hwhw.json

• next

  • create .fmt for diagram parser and emit same .py code that was written manually

git (same place as before)

Had to tweak &netsim just a little, because it was annoying me.
Added support for touchscreens, pinch-to-zoom on the graph, and tabbed out the menu bits so it'll fit properly on a horizontal iPad.

update: 2022-08-24

make all now runs 4 tests.

Test 4 contains 2 world.pys and produces {'stdout': ['hello', 'world', 'hello', 'world']}

Test 4 shows off some deep technical aspects: fan-out, fan-in, punting messge from Container to Child, Child output routed to other Chidren.

Test 3 is test2 wrapped in another layer, just to test whether it can be done.

Also fixed Hello.py->hello.py case insensitivity in MacOS. Make was failing because it could not find hello.py, whereas other tools (like vscode) did not fail on this.

Next: create .drawio diagrams and transpile them to the above .py code (diagrams as shown in the documentation. [Intend to use https://github.com/guitarvydas/das]

branch: master

(day-after jam, added Usage and Makefile to branch "master")

Usage

make

This runs run.bash which runs a single 0D Leaf component echo.py and prints its output queue at the command-line.

Test.py invokes hello.py and feeds it a trigger message (True).

Then test.py invokes world.py and feeds it the above output.

World.py is almost like hello.py except that hello.py does not echo its input whereas world.py does echo its input. World.py emits 2 outputs for each input it receives.

Both components - hello.py and world.py send outputs to their respective output queues.

The final result is:

1. hello.py outputs ['hello'] on output port 'stdout'
2. world.py inputs 'hello' on its input port, then outputs ['hello', 'world'] on its output port 'stdout'.

Test.py invokes the two components and sends them messages in sequence. This process can be generalized to what I call a Container component, but, I didn't get there before the jam ended.

Note that the .outputs () method returns a dictionary of stacks (LIFO) of values for each port. This was a conscious decision. LIFOs, Alists are what original McCarthy FP-style code used. Sector Lisp continues the tradition of using LIFOs. I think that this is one of the secret ingredients for the anti-bloatwareness of Sector Lisp. No RAM, therefore, no heaps, therefore, no mutation, therefore, simplified data access via push/pop/lambda-binding. Lambda-binding and LIFO call-stacks fit together to make small code and no-fuss structure-sharing.

Sequencing in this paradigm is explicit and caused by the order of the sends. Sequencing in most textual programming languages is implicit and is controlled by the syntax of the language (lines of code are ordered sequences).

End of Jam

The jam ended before test.py worked correctly, but, today - 1 day after the jam - test.py is working.

Post Jam

Next, would be to make a Container (Composite) component - helloworld.py that contained two components that can be chained together. Chaining is not necessary in this paradigm and I keep it only to make the examples look more familiar.

After that would come a rearrangement of helloworld.py that would contain one hello.py and two world.pys, resulting in "['hello', 'world', 'hello', 'world']"

GitHub is now up: https://github.com/DanB91/Dreamcast-Burner-for-macOS. Currently some games are working, but larger games seem not to be. Hoping to fix that soon!

I had a few minutes spare this morning so I rushed out a summary video of how MetaDocs is looking after the jam (apologies for lack of polish, I didn't have time to plan it out fully): https://youtu.be/kKppU0zcXjM

Highlights:

• reading clang's AST from JSON into C structures, deduplicating repeated nodes
• converting that into a more convenient structure for navigating symbols and their attached documentation comments
• starting to autogenerate a markdown-like syntax for symbols and attaching the documentation text
• evaluating constant expressions from the AST for enum values

Still to finish:

• representing primitive types in the same way as custom types
• finalising binary and JSON outputs
• complete example translating to a final HTML
• library methods to assist with references between documentation and symbols
• proper scoping of types

Mid-jam dev videos:
7: https://youtu.be/hgyVoYQeHFM
8: https://youtu.be/bujTibgXY5Y
9: https://youtu.be/TGmjuB506ww

Running the Lil UEFI example, which boots up a simple "operating system" that just fills the display with a changing color.

Here is the project code at the time of submission:
https://github.com/arbeiter/SDLGamePOCs/tree/ceec7d83d56193766576f85ec393a0582c49bab7

Hour 17:

Final project upload:

1. Inventory to map dragging works.
2. Item counts go down.
3. Dragging items around default color = red(should be green for a valid drop location but whatever).
4. Can't drag and drop items with count = 0 or restricted items like the helm.

Progress Update

Now supports drag and drop of items across the map from the inventory. The inventory logic is all in a single class: Inventory.cpp.
A transparent sprite is drawn when a user clicks on an item and drags it across the map.
The sprite is colored red (for now) and when the click is released, the item is "dropped" onto the map.

Future Work:

Support dragging and dropping items into crafting slots in the inventory menu.

Lil UEFI Git Repository: https://git.mr4th.com/Mr4th/lil_uefi

Final jam ship for &netsim
It's live over at https://bvisness.me/apps/netsim/ and it's incredibly jank. Enjoy!

We've got some fancy new buttons, congestion control, an IP routing rule builder, and some configurables for ACK delay and congestion control.
The best procedural musical instrument you didn't know you wanted.

Last update for the jam: I've added in a text area that captures contents from a todo list txt file, and saves edits to that same file. Usable across streams or work sessions - will save me typing up to dos every time I stream.

I didn't have much time this week unfortunately, but I managed to implement the most important features, so filtering filenames by a pattern and searching inside files works. When you hover the mouse cursor over a line in the results window it will show the context around that line and I also made a special widget for entering filesystem paths.

What didn't make the cut was code highlighting, and the filename filtering process is still single-threaded. Also the UI is way worse than I'd like it to be and there are no options for stuff like case-insensitive search and inverted match.

Implementing the path input widget took away way too much time. There are also some performance issues, like the program somehow manages to use 100MiBs of memory (maybe it has to do something with the font used).

I'll continue to work on this after the Jam, because it's nearly in a state where I would want to use it myself :D

Almost completed, just need to round up some rough edges &imagedesk

Today I added some idioms for dividing up a log of debug prints into nestable sections, showing them collapsed by default. Here's a demo of the complete experience of opening up a log file, exploring it and potentially jumping from a log line to the precise &bifold-text code that generated it.

The editing environment only knows about lines and sections in the log file; the notion of 'session', 'game' and 'trajectory' are specific to the particular client codebase/game being debugged.

Project Ambrosia - Jam Submission

Made with Odin, Sqlite3, SDL 2, and MicroUI.

Features:

• Viewing Recipes
• Ability to change units (including density information)
• Scale recipes.
• Steps with optional timing and temperature guides.
• Add ingredients
• Add Recipes
• Rounding behaviour with Fractions
• Dark Mode and Lite Mode
• Many included recipes!

Future Features:

• Search by tags
• Reverse Recipe Search - Search by ingredients and amounts
• Web App with user features
• Image support
• More recipes!

I just finished full image support! The next (and last) update will be soon. I will be diving into the world of generated web pages! &simply-slide

So far I have line stepping working :) .
I ended up spending too much time building the UI (3 days), but oh well.

To add: I'm keeping a log of the features I'm adding to the project on my youtube channel - the latest video is here:
https://youtu.be/Ot1ySSe5bjs

So, I finally added in the feature that will hopefully make this application somewhat of a reinvention: camera video capture!

The point of this application is for someone streaming to be able to see what the "viewers" see, but on their own desktop while they work away. The "reinvention" here is to make the process of setting up the UI for the stream overlay to be as effortless and intuitive as possible, retaining as many (and more) features that you get out the box in typical streaming software. I don't think this will suit everyone, but I certainly appreciate it (hence why I'm making this program). It's a similar situation to how screen-sharing works in other apps, but with a streaming twist.

And as mentioned, the addition of camera capture gives us a big step up on recreating what you get out of current video capture software. It took me a while to figure out how to get the camera video stream using the Win32 API. And as I'm programming in C, its been a real experience grappling with COM too. That is meeting my big personal takeaway from this project: to really deep dive into the Win32 and figure out what's achievable in it.

And so ends my submission for the Wheel Reinvention 2022 jam so far. Unfortunately the project is not yet in a state for any kind of release: for starters, the camera capture will almost certainly instantly crash the application on any other computer... magic numbers abound! But this will be a long term project (I'm giving myself 2 years on this one...?!? famous last words), so let's see what we can do with it.

So everyone's posting their jam entries. It's much less than I expected, but here it is anyway. &printf2. The entire point is to just have an off-host logging monitor. The logging monitor can visualize more than just a simple console, with things like bitmaps. Did I leverage that? No of course not, thanks to me being very lazy. I tried to use it as a library, can't say it's particularly useful yet 😂. https://github.com/skejeton/printf-on-steroids

Final update for the jam for my &movie-editor filmsaw! Added project loading/saving and also added very unsynchronised audio playback. Also fixed a couple of bugs particularly the aspect ratio when drawing thumbnails. There are still lots of bugs.

Nothing new in this gif, just wanted to update the project board and say that I think abbrv made it for a 1.0 (actually 1.1!) release before the jam closes. A very simple project, but ultimately pleased with the progress. Ideally I'd want to make it work for MacOS as well, but for the end of the jam just working on Windows is enough for me. You can grab the release here: https://github.com/jakemason/abbrv/releases

I'd greatly appreciate any/all feedback or bug reports. I figure I'd give this like a week after the jam closes, fix any bugs found and then mark a 1.X release that isn't flagged as beta. &abbrv

I didn't end up with something visual or interactive, but it was very insightful.
I was trying to make a CAD app and use metaprogramming for it as much as possible.

What I did:
1. Day: Trying out metadesk and think about how it might help with me creating an app. I realised it is good for describing data, but not so good in describing a program.

2. Day: Trying out sokol_gfx and sokol_app. Also wrote a metaprogram that just takes a DATA_main.c file (in which I write the app in) and turns it into a GEND_main.c file (GEND=generated). I did some keyword replacement just so the metaprogram does something.

3. Day: Started writing the app. I decided that I want a rectangle-struct for basically everything on the screen (backgrounds, buttons, text, ...). I didn't end up writing much code for it though.

4. Day: Now that everything is just this rectangle-object I can describe most of the program in a tree structure. So I did create a META_DATA block (it is a variadic macro so my IDE wouldn't mark it as syntax errors) that holds metadesk data describing rectangles (and other stuff). The metaprogram reads that block and adds the rectangle creation code to a location I marked in the code.

Conclusion: I now have a nice setup for adding arbitrary data in my program and generate code from it.
Running a metaprogram on your code, even when it doesn't do much, can help thinking on a higher level and I think it helps making your code shorter and focus on more relevant things.
&bewehr

Squeezed one last feature on &orca before the finish line. Launching apps from the browser, with a choice to cache them for offline use.

https://github.com/guitarvydas/eh

Implemented TCP sending / receiving, with retransmission. It now reliably transmits data even if the network is unreliable! (In this example, one of the connections drops 10% of packets.) &netsim

Building the website via command line is simple and of course, very fast

Minimum configuration is required. Convention is preferred over configuration for the most common task, that is adding posts.

Adding content is just a matter of adding html files to the Posts folder.
The post file name states the template used to render the post, the post creating date and the post title

&multiedit Just to see how easy it is to convert anything to a multiedit plugin, I ported my old solid state visualizer into a plugin.
Also showcases you can do literally anything with plugins here.

&sdf Final stretch, more editor features, and cleaning stuff up
https://gfycat.com/sleepyquarrelsomeachillestang

2-minute demo of how far I've gotten with &bifold-text. Ends pretty much as you would expect.

Today was mostly polish. Lots of fiddly background stuff, like hooking up session storage so it'll save the fact that you muted it across refreshes, a little bit of input handling (space is now start/stop), and some mild visual tweaks to make logs more legible. &netsim

Not much visible progress on &orca today, but I did a lot of background work!

• I now load and run real wasm modules in the tab processes, and compile shaders and call gles from them.
• I also wrote a crappy python script to autogenerate (most of) the API binding code (some of them are more tricky to automate, because the require knowledge of the semantics of the arguments, e.g. glShaderSource, so I write binding code for them manually).
• Oh and I also designed a simple messaging protocol between my processes, and can send input events to the tabs. Then if the wasm module provides a handler for that event (i.e. defines a function like OnMouseUp() or OnFrameResize()), this gets called automatically (i.e. no need to register input handlers).

So now I can click to change the direction of rotation of my triangle. Phew! But to be fair, I warned you that there's wasn't much eye candy today!

&sdf I'm not procrastinating, you're procrastinating :owlofshame:
https://gfycat.com/likableoddhusky

Didn't have a lot of time so I didn't finish or get much done for my jam project, but at least I have something...
It modifies .obj's and inserting tracing code. When you run your program, it records where branches and calls are going, and saves that to a file. Then, the user can use another program to view the data which deduces the full execution path and you can look at what your program did, zoom into function calls, etc..
I also wanted to make it work for indirect calls & jmps and in general for bigger programs, and add searching capabilities and recording function args and return values, but alas, no time. That would allow you to do things like search for where in your program you allocated memory, match malloc's to free's, investigate use-after-free's, etc.. &rainman
Also fun fact: a recursive function actually exhibits a Droste effect

&simply-slide I added project support, you can have multiple projects and everything!! It also loads your most recent project on startup

&sdf Added support for reflecting sdf primitives
https://gfycat.com/oldfashionedidlebrahmanbull

&cork started work on functions calls, ideally i can do retyping tommorow so that my display of arrays isn't incorrect

Changed the SendInput() API calls around to send one big batch of inputs instead of multiple calls. This makes longer string insertion much faster. &abbrv

&sdf Adding some features to the editor to allow the user to... y'know, edit
https://gfycat.com/secondhandpoliticalamphiuma

&simply-slide You can place text, edit every aspect about it, and delete (forgot to show that in the video). Creating new slides works and also deleting them (again, forgot to show that in the view, sorry)

Some fun new bits/pieces today! We've got TCP logging, simulation controls, and some slightly tweaked colors. &netsim

There it is! Probably the world's first successful burn on an M1 Mac of Xenocrisis for Dreamcast!

Midpoint progress

Phew! I Finally figured out a way to do cross-process graphics. So now I can give each tab process a GLES context, that can be displayed inside the main &orca process. To celebrate I'm having some remote triangles!

Doing the TCP handshake, and sending and ACKing data! &netsim

Added "Log monitoring" to &printf2

&multiedit a basic particle system plugin in 183 LOC. Yes it's very barebones, but it works!

I seem to be past the "black triangle"[1] phase of my project &bifold-text, so tonight I had some fun. I built a little game using my new text editor. Here's what the source code looks like normally, and revealing debug prints. Finally, just for eye-candy, a video of me playing the game. You'll have to trust me that the debug prints work 😃

[1] https://rampantgames.com/blog/?p=7745

&multiedit Multiple plugins and Window resizing done. key events, mouse button events and resize events are now accessible through plugins
Now for the fun part (Trying to make a particle system editor as a demonstration)

&cork Got the variable renaming working!

&simply-slide You can now edit the background of the slide, select slides to view, and save not only the slides but the exact slide you had selected. Thanks to Martins and x13pixels for ImGui help!

Got this working earlier this week, but figured I post it. CDI file parsing is going well.

&sdf lerping between sdf's with set keyframes 🔥

A less interesting, but still important, update: we can now ship a single .exe file with fonts and any/all other required pieces embedded in the .exe. Once you add entries, your .exe is joined by config.abbrv that contains all your saved data. Moving data between machines is as simple as copy/pasting that file between them. &abbrv

Network-sim-as-an-instrument, now with more graphs! &netsim

Intro video to my jam entry &orca https://youtu.be/1HM-VUi2YlE

&multiedit Quite a bit of progress since yesterday, added proper plugins and rendering via them is super easy

categorizing logs by files &printf2

After a bunch more work and one LLVM bug (🙃) we have better visualization of dropped packets, plus a lot of other little animation polish things. &netsim

Now the organizing part this image organizer finally begins &imagedesk

After some hard work by @bvisness, we've got some fancy animations for packet routing / buffers! &netsim

&cork Got my first function converted over using my Decompiler, it's slightly broken but almost there

Fractional Unit Showing and basic rounding

Ability to Add Ingredients (with default units, and plural names)

Ability to Add Recipe

My &movie-editor Filmsaw is coming along nicely 🙂 managed to add a source window that opens videos found on the filesystem. You can drag videos onto the timeline then chop them up with X and delete them with Delete. Lots of improvements left to make but the basics are working now I think - hoping to get audio working next. Then I'll probably look at how horrific getting videos exporting is. FFmpeg is amazing!

Day3 - The &orca launcher now loads metadata from the app bundles it finds in the local apps folder. You can click an icon to select an app and see its banner and description. Double clicking creates a new tab backed by a separate process.

&multiedit Had to rescope a bit, panels were causing quite a pain for rendering for plugins. so wasted a day on that.
In other news, I got the file explorer bit working today, with queries!

Viewing an 16k image without optimizing the render (I'm just using SDL for the jam) is way faster the some image viewers &imagedesk

First jam update report! Been making pretty good progress so far.

Got ffmpeg opening videos and displaying them on the screen but single threaded and no audio yet.
You can seek the video and I'm using that to generate badly sized clip thumbnails.

I've also started work on the track editor and you can move clips around and chop them in half. I have also added undo/redo support for the clip editing which is all working nicely. You can't delete stuff yet.

I'm working on the sources panel on the left next which will display videos in a folder and allow you to drag them onto the track editor to add them to the film.

Once that bit is working the plan is to see if I can get the video panel to display the film you are editing, taking the clips etc into account!

Some more kinks worked out, input/output seems bugless (so far) and we now support multi-line expansions. Saving and loading works without issue and happens whenever a pair is added, removed or modified. Thanks to Martins I've also resolved a number of Windows System Tray Icon woes! I'm very pleased with this progress so far -- I'll need to start researching the MacOS implementation details starting tomorrow. I assume that'll take a lot more time as I'm far less familiar with that environment... &abbrv

We are simulating routing! Packets are moving through the network 😃 &netsim

&simply-slide I setup ImGui and SDL2. I also got the basic UI layout setup. Gonna be working on loading in a .ini and dynamically loading slides/resources based off the .ini

&sdf lerping between different sdf entries 🔥

&sdf When everything's a distance function, hit-testing / mouse-picking is free. (Animated Undo/Redo on the other hand, is gonna cost ya :drugz:)
https://gfycat.com/wellinformeddrearyeskimodog

Current progress of Day 2 of the Jam. A "forward" cookbook with decent unit conversion done with the ability to convert between mass and volumetric units! (It knows the density of the ingredients)

Walking the filesystem tree and parallelized regex search mostly works. I'm using the PCRE2 library for regexes.
Filtering files by name doesn't work yet at all and I think that will have to be also parallelized.
A rough draft of the UI is also done, just enough to test things. I'll probably have to make my own controls because the textbox in raygui seems to be very basic (i.e. can't select text, no key repeating).

Capturing all the instructions executed by a program &rainman

Mostly successful Windows build for &abbrv ! There's still some work to be done on this version, and the entire Mac OS platform layer to do, but I'm very pleased to be so far along already. I think I chose a reasonably sized project for the jam 🙂

Added threading, now it outputs them all at once. &printf2

Image organizer going well so far. Done much more progress than I expected by now

Enchancing printf debugging! Starting up with making sortable logs.
It's still very crude and it's synchronous for now as you can see by the logs not appearing immediately.
&printf2

Just a very crude UI mockup for the first day! The OS is making handling animations during resize overly painful, and I spent way too much time on this :lol_sobbing: &orca

Not much progress today.. I may have bitten off more than I can chew. What else is new? 😅 &bifold-text

At last...we have "simulated" a "packet". &netsim

&multiedit Got basic panels working. Should be easy to attach plugins to them which is the next step

&sdf Basic rendering of SDF primitives for an atlas entry

&gollash Processes communicate with stdin, stout and stderr. What if we could make a node editor UI where you can create a script, but instead of using the weird bash syntax you can have a nice UI where you connect nodes the way you want.

so far I've only built a small part of the UI 😄

&cork I've made TB bindings for Odin using Cuik to handle the automated labor with me filling in for the limits of it. I'll be needing it for the code analysis stuff that i'll be doing.

Probably won't be able to work on this more today, so it's time to consider this day 1 of &vireac. So far it's just parsing a copy/paste of its own assembly code from msvc into a bunch of colored circles, but all the different instructions are distinguishable, and I can scroll through them easily. Step 1 is complete.

Step 2 will be grouping them up based on the c++ code that produced them, and trying to make them visually distinct by shape rather than color.