Notices by dave (dthompson@toot.cat), page 2

I'm currently seeking VC funding for an Instagram-like app for punks. The timeline looks like a local music venue bathroom stall and you can only post band stickers onto it that cover up the older posts.

yeah there used to be a cool Screaming Charlies sticker by the wall but it was covered up by a Commiserators one. they fucking suck and they never bring their own amps to shows.

(I made these names up without checking to see if they are real bands)

@janneke does this work for all architectures that guix supports or a subset?

@janneke holy shit I didn't know that this much progress had been made in bootstrapping. I thought we were still maybe years away from full source bootstrap. incredible work!

The Lisp Game Jam has begun! 60 registered participants! This is a 10 day jam so still plenty of time to join in if you want! https://itch.io/jam/spring-lisp-game-jam-2023 #lisp #scheme #gamejam #gamedev #lispgamejam

We are 1 month away from the next Lisp Game Jam! Make a dating sim in Emacs Lisp. Or make a Souls-like in Chicken Scheme (aka Chicken Scheme for the Souls.) Or make a kart racer in Fennel. Or make a post-apocalyptic action platformer in Common Lisp. Or make a roguelike in Racket. Or make a farming sim in Guile. Or make a strand type game in Clojure.

https://itch.io/jam/spring-lisp-game-jam-2023

#lisp #scheme #gamedev #gamejam

@cwebber it's very nice if the system allows unprivileged namespaces. the bundles are huge but it "just works" (sans that one big caveat)

@cwebber @civodul yeah that "clone failed" error is an indicator that namespace stuff failed.

@cwebber @civodul heh maybe, though flatpak takes a lot of system stuff for granted so the packs are much smaller. I know that it would be possible to generate bundles that make similar assumptions using guix, but it requires using a modified compiler toolchain, using the oldest glibc feasible to ensure the binaries will run on the most systems, and making package variants that produce binaries that don't refer to /gnu/store.

@cwebber @civodul ooh yeah that would be cool. appimages are kind of like this in the sense that they are one executable, though they contain a disk image inside. love2d stuffs everything into a zip and uses another icculus project https://icculus.org/physfs/ to pretend it's a file system. because lua is so minimal and doesn't provide a file system access api, love2d games are quite secure in that they can't really access much. they can also write to a save file that love2d controls. gives off some least privilege vibes. would be cool if my games could use guile sandboxing to enforce the same limitations.

The next big step was hacking this compiler into my existing shader code so I could actually use the shaders and test that they really work. This required a linking pass that does a bunch of renaming on the separately compiled vertex and shader stages to ensure that vertex output names match up with fragment input names (GLSL needs the names to be the same, ugh!) and that uniform variables between both stages use unique names because they share a global namespace.

ahhh I got my single sprite and batch sprite shaders ported over and *they work*!!!

My most complicated shader port yet: the stroke and fill shaders for my vector graphics renderer. https://gist.github.com/davexunit/83e1ed3d71ea11f48e30fc8cc0d568ec

here's a more complicated shader that I ported to seagull. I use this for stretchable dialog boxes. https://gist.github.com/davexunit/5d9c4f707c349e3a5aada5dae1ce674d

Seagull is feeling pleasantly Schemey! There are two big missing features in the language: Loop syntax (GLSL *severely* restricts looping and recursion is *not* allowed so a loop form is essential, unfortunately) and user defined structs. I already have define-shader-type syntax that I've been using with my existing GLSL shader code so I just need to a way to import those into Seagull code and have the compiler generate the GLSL struct declaration.

I seem to have gotten a very basic qualified type thing working. still need to noodle with it more, though.

Qualified types introduce a type predicate that needs to be checked after inferring each expression. For example, let's say the signature of '+' is 'a, a -> a' where 'a' is any type. Addition only makes sense for certain types of data, so we can then specify which types are valid with a predicate. For example: where 'a' is a float or an int. Adding two booleans is valid as far as the function signature is concerned, but it will then fail the predicate check.

One limitation of this approach seems to be (meaning I haven't found a paper/article stating otherwise yet) that it cannot express all of the possibilities of function overloading. For example, in GLSL it is valid to multiply a matrix by a vector. It is also valid to multiply a vector by a matrix. Both forms return a matrix, but the signatures are different. The first is 'a, b -> a' and the second is 'b, a -> a'. This would require two differently named functions in a qualified type system.

What might be useful is allowing for a signature like 'a, b -> c' and associate substitutions with predicate conditions. If 'a' is a vector and 'b' is a matrix then substitute 'b' for 'c'. If 'a' is a matrix and 'b' is a vector, substitute 'a' for 'c'.