I wrote a blog post describing Orca's vector graphics backend: https://orca-app.dev/posts/240426/vector_graphics.html

!til late addition to my learning jam project on &colors: how to derive the HSL/HSV color models from an RGB cube: https://youtu.be/1zwXnf0G2II

!til the sRGB curve is slightly different from a simple gamma curve, and the difference is actually noticeable on darker &colors. So here's a follow-up video on the proper way to do sRGB conversions: https://youtu.be/T54SX-QwFpc

!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

!til a bit about &colors, so here are some ramblings about the XYZ color space and xy chromaticity diagram: https://youtu.be/IOJe1ugkc9Y

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 wrote about the styling system I use in my UI toolkit, which solves some problems I had with stack based approaches: https://www.forkingpaths.dev/posts/23-03-10/rule_based_styling_imgui.html

Porting my vector graphics renderer to opengl on windows (All glyphs are re-rendered from vector outlines each frame).

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

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!

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!

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

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.

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

First draft of a completion panel in Quadrant's structure editor. It's not hooked up to the type system and symbols tables yet (so for now it only suggests syntactic constructs), and there's still a lot of little UX decisions to be made in order to provide a fluid completion workflow, but I think the general idea is working pretty well. &quadrant

Doing some UX experimentation for &quadrant structure editor: here the editor is automatically inserting "holes" for missing tokens, with syntactic/semantic hints, while trying to retain a "text-like" editing flexibility.

Here's a short presentation I made for the Sound and Music Computing Conference 2022. I go over the goals and approach of my temporal programming environment &quadrant and then demo how you can pilot a Max/MSP patch from a Quadrant program using OSC.

https://youtu.be/6nC2M3NwDe8

Follow-up to my first contact with fluid sim: I implemented what I understood of the multigrid method. Still unsure if I did get it 100% correctly (need more testing) but it seems to address some obvious issues of the first try!

Lately I've been trying out using minimal C to WebAssembly as small practice sessions in my spare time. I'm also kinda curious about fluid simulation, so this week-end I took the opportunity to learn some basics and whip up a small demo. It was a lot of fun 😄

Some progress update on Quadrant's language features: variadic parameters, polymorphic procedures, modules, and foreign system: https://youtu.be/AmO9hczGkYU &quadrant

I rewrote the layout strategy of &quadrant. A cell can now adapt its layout to the layout of its children (so it can avoid unwanted hanging indents or break lines when its contents gets too large). I also took the opportunity to add smooth animation to the cells and cursor's position.

A little more detailed presentation/demo of my prototype temporal programming environment &quadrant. https://youtu.be/_wGPEDwp1AA

Prototype of a programming environment I'm working on, called &quadrant. The end goal is to write temporal scenarios for live shows/art installations. It has a structure editor, a non-textual DSL that gets compiled to a bytecode which is then executed by a VM. The VM and the editor communicate, which allows monitoring and controlling the execution of the program from the editor.

Here's a short demo of the curve UI

Day6 devlog (I couldn't work on my Jam project on day5): https://youtu.be/DmmKoz8XiJo I added a simple UI autolayout system and implemented dial knobs and a curve editor.

Day3: added code reloading, and a basic project settings file allowing to specify a build command to build the dsp code from the application with a keyboard shortcut. Also did some fancy overlapped dll loading to avoid shuting down the audio during reload.

Day2:

• Learnt how to query and configure audio devices from the application in CoreAudio.
• Added popup menus and number boxes for audio configuration.
• Added basic peak level meters for input/output.

I'm definitely not a fan of the CoreAudio API, and there's still a lot of kinks to iron out, but it will do for now!

I got some basic structured editing working for a scripting tool I'm making.