Hi everyone 👋 I’ve been working on a JavaScript implementation of Sussman & Radul’s propagator model and wanted to share some progress + questions. here's the link to the repo: https://github.com/Semi-0/Propagator I currently have two branches: a. A custom push-based version (works, but

amb

can get weird). (In the AMB branch) b. A more *f*aithful scheduler-based version, closer to the original design. (but amb still acts weirdly when execution gets large) It supports almost all of the original Scheme machinery, and I’ve been experimenting with a reactive extension so propagator networks can drive UI updates. Lately I’ve been exploring some theory: I noticed interesting parallels between wired diagrams in category theory and propagator networks, and I’m researching how to separate representation from execution (syntax vs. scheduler). And how I can perhaps making the propagator more self-reliant as independent programming languages. Since I’m pretty new to open-source, I’d really appreciate advice on two fronts: 1. Research direction → does this “wired graph - propagator - representation/execution” connection resonate with anyone? Are there papers or projects I should look at? 2. Sharing the code → what’s the best way to make an infrastructure repo like this easier for others to understand? (Docs? examples? small demos?) Thanks in advance for any pointers

I’ve never actually worked with propagators - they’ve always been a little academic for my needs, but I am interested in them. I’ve written reactive/incremental compute systems from scratch, and there’s a little resemblance, but I’ve mostly just heard about them from seeing some talks online and reading a bit about it. I’m curious the scale of system you’ve built with propagators.

i am primarily an artist and designer working with multi-media, so i work with propagators more frequently on creative exploration. The current prototype face scalability issues because all the intermedia value are retain in the memory, this gains expressiveness but also creates memory pressure. i think this could be solved by distinguishing between discrete and continuous cell. What draws me to propagator is how they enable language level expressiveness while the topology of graph is traceable and modifiable at run time, and all the value is inspectable. Also compound propagator reinforce composable structures naturally. Most reactive systems i encountered in production level seems to deviate from the core ideas in the FRP from first principle and original Haskell implementation of FRP around behaviour composition, like (draw (circle mouse-position)) where every behaviour is a pure function, so they maintain predictability and testability. And in Propagator because every cell is continuous value, therefore you could have similar behaviour composition.