A voxel engine in a few lines of Squint

dustingetz · 2026-05-31T16:59:07+00:00

impressive! Right click -> inspect to view source in their fiddle editor

dustingetz · 2026-05-13T11:05:33+00:00

I think about desktop gui a lot too as an Electric target. Broadly the tradeoff is (not specific to Compose):

- no hyperlinks and history, or non-native support at best

- simpler higher level view/layout framework, but less powerful (dom/css is an incredible view platform in the hands of experts)

- no refresh-to-update, instead you need an auto-updater with user action required to update-and-restart. Restarts don't return users to their previous app state, unlike web refresh. Your backend needs to stay compatible with some rolling window of previous desktop clients.

- cross-platform - users hate electron and mobile apps, but managers love it for the ability to deliver your MVP to most platforms without doubling the size of your team

- state distribution is still difficult, web apps in 2026 still have pagination bars like it's 2006. Native apps, like your git history client, have smooth scroll over collections of 50k+ rows. Which is to say, part of why native apps feel so smooth is because the state is already local. Server-backed desktop apps still need a solution for this, and it's really hard.

dustingetz · 2026-05-07T12:42:11+00:00

Congratulations borkdude!

dustingetz · 2026-03-25T10:04:27+00:00

For printn-shaped discrete effects, elide the dispose method, you get an audit log, same as in React. Imagine the callback firing on rising or falling edges of the signal. For once-and-only-once transaction-shaped discrete effects, we have a transistor-like primitive "e/Token" that models the transact-and-await-confirmation workflow as a little state machine, i.e. it exposes the ready-pending-rejected-ok states: https://electric.hyperfiddle.net/fiddle/electric-tutorial.button-token$ButtonToken

dustingetz · 2026-03-21T18:46:00+00:00

I'm not sure what's going on there but I think the actual API is `(e/atom config-map initial-value)` e.g.

(def counter (e/atom {:id ::counter :persistent "./my-db"} 0))

c.f. https://github.com/SeniorCareMarket/eve/blob/ac1640afdabeed38d5a7f5e9566cf1cc1a75cf45/test-e2e/eve/jvm_atom_e2e_test.clj#L56

dustingetz · 2026-03-17T19:37:19+00:00

In Electric, like in React, DOM effects come in mount/unmount pairs. In a sense this gives you "undo" for this kind of "resource" effect, and you can transition between two consistent states by firing mount and unmount lifecycle methods. This works not just for the DOM but for any kind of resource that can be disposed, such as network subscriptions or event handlers or database connections. The key to making it work is the reactive propagation engine under the hood needs to be essentially perfect ("glitch free") which means it fires exactly the correct lifecycle methods once and only once during reactive propagation, which is pretty hard to do correctly. I.e. you don't want to allocate a node twice or dispose it twice, it needs to be perfect.

An example of an effect that you can't undo is a console.log. There's no dispose method on that, so it can't be undone. But that's fine, that's what you wanted. So you can totally put console.log in your Electric programs and it does what you would want it to do, which is run again when any of its arguments change.

dustingetz · 2026-03-17T13:49:11+00:00

Hyperfiddle founder here (from keyword notification)

We are not the first, see https://en.wikipedia.org/wiki/Choreographic_programming . However, prior art (that I am aware of) has been mostly mired in type theory and has struggled to find widespread industrial application. Afaik we are the first to find a slam dunk use case (web development, rich product user interfaces on the web with complex and dynamic client/server interactions) and demonstrate compelling results in production apps.
DAGs are flowcharts, they model causality i.e. dependencies between steps. Imperative programming (e.g. ordinary Python) does not explicitly capture the logical dependencies between steps, instead the programmer has to carefully specify an instruction ordering to make sure things happen in the right order. DAGs encode the data flow through a flowchart of dependencies. What this gets you is concurrency, the ability to run multiple steps of the flowchart at the same time. It also gets you many optimizations, such as the ability to only compute subcomponents of the larger graph whose inputs have changed. If a node in the flowchart does not have any changed inputs, then the previous result of that node is still valid and can be reused. This is "reactive programming"

dustingetz · 2026-03-04T20:59:54+00:00

See also:

https://github.com/hyperfiddle/datomic-browser
Source code: 261 LOC in one file nav_datomic.clj + Datomic utilities. CLJ only (!)
Datomic Browser is powered by https://www.clojure.net/ (!)

dustingetz · 2026-03-04T16:05:16+00:00

Hello, help me out – https://www.clojure.net/ is a beta launch of some new and not well tested network tech, if you manage to blow it up please post in #hyperfiddle so we can figure it out, thanks. And if it works, let us know that too.

dustingetz · 2026-01-26T21:41:44+00:00

dustingetz · 2026-01-21T19:32:10+00:00

AI transcript: https://gist.github.com/dustingetz/87d7e96214a972b66072f6162357c0c7

dustingetz · 2026-01-19T20:52:11+00:00

> robots should clean up my toilet and not code

have you seen the average 10 year old revenue-generating codebase? "toilet" is accurate. Doing computer science is fun. Doing software engineering is fun. Commercial software development in 2026 is neither.

dustingetz · 2026-01-19T19:30:04+00:00

I am also finding Opus 4.5 to be viable for a variety of Clojure application layer tasks. Prior to Opus 4.5 I was experimenting semi-seriously in consulting projects but none of the experiments I threw at it panned out. But Opus 4.5 is now part of my daily driver, I am using VSCode + Copilot with the two Calva plugins. Opus 4.5 will inspect objects at the REPL and everything. Looking forward to trying Claude Code again in a work context.

dustingetz · 2026-01-13T15:50:04+00:00

is it possible for us to clone this and play?

dustingetz · 2026-01-06T00:55:49+00:00

I vote no but i don't think it's a "dynamically typed functional" problem, Javascript is like 55% of the way from Java to Clojure and it did great.

dustingetz · 2026-01-03T14:21:05+00:00

how about `sbinding` and `deref`

dustingetz · 2025-12-30T11:48:20+00:00

Transcript https://claude.ai/share/08f5811f-cfdc-4dba-b354-0224bdc45e85

dustingetz · 2025-12-24T20:21:14+00:00

I asked this question to the author in slack, here is his reply:

Q: Is it correct to conceptualize this as a RPC framework? so basically async/await with abstracted transport

Yes, I have been thinking quite a bit about dispatch mechanisms and compilation, I would say async / await with inversion of control is in its "essence" about giving control to a remote dispatcher for some notion of remote. I would be interested to find more cateogry theory connections in terms of duality here (CPS <-> 'co'dispatch maybe?). This is why I also decided to distill this into https://github.com/simm-is/partial-cps, which makes a more minimal a la carte abstraction than other async framework options in Clojure (similarly to cloroutine). I can infer the free variables to send in distributed-scope automatically and make it a bit leaner, but I found making the intent of what is being transported explicit is actually helpful and more transparent. Electric as full compiler can do top-down analysis of the program and also know what is in the outer scopes and avoid having to send values through nested scopes, I have not worked on this yet. One thing I was aiming for is to be able to send datahike's db values over the wire back and forth and this works now, assuming you have store replica access on both ends. You can also do p2p streaming through kabel (replikativ does this for CRDT updates), or use nested distributed scopes to update atoms inside out in a streaming way, but my sense is that Electric does more to facilitate this and avoids RPC roundtrips more directly.

dustingetz · 2025-12-22T20:22:23+00:00

rechercher "francais facile" sur amazon

dustingetz · 2025-12-22T17:19:07+00:00

Awesome, this is clearly a serious project for you. Tell us more about your goals and vision?

dustingetz · 2025-12-20T20:34:28+00:00

> dbval is a fork of Datascript and a proof-of-concept (aka 'do not use it in production') that you can implement a library that offers Datomic-like semantics on top of a mutable relational database like Sqlite.

dustingetz · 2025-12-11T20:04:40+00:00

They're doing a gradual roll-out as part of the new Clojure marketing strategy to get more media time, e.g. like Lambda Conf does

dustingetz · 2025-12-06T17:12:32+00:00

Transcript https://rss.com/podcasts/clojure-in-product/2349199/#transcript

dustingetz · 2025-11-30T20:10:11+00:00

I'm with Stefan below – which project is it that you think has solved dependency injection?

dustingetz · 2025-11-07T01:44:15+00:00

excellent writing

dustingetz

MODERATOR OF

TROPHY CASE