proposal-signals

and Salsa is an example in general incremental computing, used in rust-analyzer. Another way to look at this sort of thing is as a build system with automatically tracked dependencies. One such build system is tup, which instruments build jobs to detect what files they read to establish dependency relationships. Interesting reading from the author: https://gittup.org/tup/build_system_rules_and_algorithms.pdf, see also the classic Build Systems à la Carte https://www.microsoft.com/en-us/research/wp-content/uploads/...

t allowed for clean, dynamic object handling without the "magic" workarounds required by descriptor-based reactivity. - Standards-First: I’m building Signet to be a thin orchestration layer. It currently leverages `@preact/signals-core` for its robustness, but the architecture is designed as a drop-in reactive layer. My roadmap is to align the internal primitive with the upcoming [TC39 Signals Proposal](https://github.com/tc39/proposal-signals), treating Signet as a bridge to native browser reactivity as it matures. ## Why did I build Signet instead of using [Alpine / petite-vue]? The `petite-vue` Gap: Petite-vue was the gold standard for "sprinkling" interactivity, but with it no longer being maintained, there's a real need for a modern alternative that bridges the gap between pure HTML and heavy SPA frameworks. Solving "DOM Pollution": A common friction point I found when moving to Alpine was the "messy DOM"—state-heavy applications often left behind excessive attributes and listeners that made the DOM feel cluttered. Signet is architected to be "DOM-transparent," ensuring that reactive bindings don't leave a trail of debris when components unmount. Signal-First Architecture: By building Signet directly on a Signal primitive, I’m opting for a "Reactive-first" model. This is fundamentally cleaner than the directive-heavy, "magic-attribute" approach of previous libraries, leading to more predictable data flows and easier debugging. ## Memory Stability: I ran a 10,000-component mount/unmount stress test using WeakRef to verify garbage collection. The results confirmed stable heap usage, proving that you can achieve leak-free reactivity with Proxy if you manage the dependency graph lifecycle correctly. ## A Note on Implementation: I approached the development of Signet as a human architect utilizing AI agents for the implementation. My role was defining the constraints (e.g., bundle size limits, dependency lifecycle logic, memory stability) and enforcing the "clean DOM" architecture, while the AI handled the boilerplate and repetitive logic. This allowed me to iterate on the internal signal graph and performance testing at a speed that would have been impossible manually. This project is a deliberate experiment in "AI-assisted architecture"—where the human provides the technical constraints and domain expertise, and the AI acts as a high-speed implementation engine. I also let the AI implementor construct the full document site at https://sntran.github.io/signet.js/.

has become dominated by influencer developers, to the point that junior developers entering the field are not aware of other ways of building web applications. It's strange how you completely dismissed Solid, Vue, and Svelte which all offer a different way to build web apps when compared to React, for example. > JavaScript in web browsers is a stable, modern language. You need more than just a language. You also need libraries and actual useful functionality exposed by the browsers. Literally the whole reason so many libraries and frameworks have popped over the years, is because no one wants to spend time writing hundreds of lines of code just to properly set up and change some DOM element. And the reason very few libs/frameworks (even newcomers) use "the amazing new features in the browsers" is because these features have a list of features issues and caveats a mile long. Here's just one single example: https://x.com/Rich_Harris/status/1841467510194843982 > HTML has received numerous transformative updates over the years, such as the `template` element we're discussing here. And what, pray tell, does template give you? On its own it's useless. You need some JS to manipulate it, at least. > but because it takes a first principles approach and rejects building on top of the existing pile of abstractions. Didn't you just say this: "The entire idea of writing fake HTML that gets parsed, compiled, and interpreted in JavaScript to manipulate the DOM at runtime is wrong. "? What do you think Datastar is doing if not literally the same thing. How do you think this works: <div data-signals="{counter: 0, message: 'Hello World', allChanges: [], counterChanges: []}"> <div class="actions"> <button data-on-click="$message = `Updated: ${performance.now().toFixed(2)}`"> Update Message </button> <button data-on-click="$counter++"> Increment Counter </button> <button class="error" data-on-click="$allChanges.length = 0; $counterChanges.length = 0" > Clear All Changes </button> </div> <div> <h3>Current Values</h3> <p>Counter: <span data-text="$counter"></span></p> <p>Message: <span data-text="$message"></span></p> </div> <div data-on-signal-patch="$counterChanges.push(patch)" data-on-signal-patch-filter="{include: /^counter$/}" > <h3>Counter Changes Only</h3> <pre data-json-signals__terse="{include: /^counterChanges/}"></pre> </div> <div data-on-signal-patch="$allChanges.push(patch)" data-on-signal-patch-filter="{exclude: /allChanges|counterChanges/}" > <h3>All Signal Changes</h3> <pre data-json-signals__terse="{include: /^allChanges/}"></pre> </div> </div> It does (ab)use the browser for the preliminary parsing, but then it does what everyone else does (only probably worse). E.g. by literally parsing attribute contents to reimplement half of Javascript for "reactive expressions": https://github.com/starfederation/datastar/blob/develop/libr...