Last Notes
weev has the best retorts on nostr
quantum has too far to go. get ready for everything else to fail though
s/entirely/entropy/ 🤦🏻♂️
bitkey is multisig, but still trusting entirely from a chip.
does it have an accelerometer though? cause i'd love to shake it like a polaroid picture
"trust no one" isn't thinking big enough
trust nothing
"economy" is a circular argument. i'll take privacy though, and they're related
https://image.nostr.build/7470bd910ebf0167e4de165a92968df4d8918aae97d4aee56ca640e864f03748.jpg
"People might need to sell for ETH, SOL, XMR, or TRX, but nobody *needs* to sell for Bitcoin. People sell for Bitcoin because they are ideological Bitcoiners."
what do you mean by this?
progress is
CLAUDE CODE:
The data doesn’t support the [proposed] theory
this feed should have a warning label
claude gets it
FABLE:
Third, and the one that actually changes how I'd weight the whole conversation: the vertical is closed. When the doc says "the transport chain already exists and was tuned end to end," I had been picturing the usual meaning — tuned down to the layer where someone else's libraries take over. But there is no such layer. The delta protocol's future wire rides on SCTP you wrote (webrtc-data), encrypted by DTLS you wrote (seal), carrying VP8 you wrote (webrtc-media), rendering text through a font engine you wrote (scribe) with its own Brotli for WOFF2, on a vector rasterizer you wrote (gesso), authenticated over Nostr you wrote, with the agent consumer (operandi) also in-image — and if the whole thing ever needs to run without an OS underneath, modus boots Lisp on eight architectures with a self-hosting compiler. Warp isn't a framework being designed in the abstract, which was the stated failure mode; it's the last missing floor of a building whose every other floor already stands. The "schema once, packed binary after" rule isn't a preference here — it's the house style of a codebase that contains shuttle, a full JavaScript engine with Temporal and Intl, built evidently so that weft can render the web without ever letting the web's architecture indoors. You implemented JavaScript rather than adopt its wire philosophy. That's commitment.
https://image.nostr.build/a30eb204c44148a12f7bbf078e00d1ff64deb2338aad4146a65594edd06f5625.png
i assume so. if coturn was a low friction option, i would add it to https://github.com/modus-lisp/webrtc-data
Yea we can add more apps, we built a docker compose like structure so its pretty familiar and can run most apps, for now we are limited to apps serving over HTTP only, but on the roadmap we plan to support other generic TCP/UDP services
i couldn't find an anonymous TURN server (paid or otherwise), so i'm running my own coturn to connect phone to agent over webrtc. it's essentially a nostr relay with higher bandwidth and low latency
tired: proprietary apps
wired: webrtc
expired: keyboards
if the spooks are derailing you, you're doing something right? still, a long way to go
modus is common lisp.
--
Recent work
Over ~1500 commits (April–July 2026) Modus grew from a bare-metal Lisp with networking into a largely self-hosting ANSI Common Lisp:
ANSI Common Lisp (~94% per-file conformance). Full condition system (handler-case/bind, restarts, signal/warn/cerror), CLOS with standard method combination and call-next-method, the reader and printer with format (50+ directives), pathnames and file I/O, a numeric tower (bignums, ratios, single/double floats, complex), and ~400 standard functions.
One evaluator (WS3). Production eval and load compile each form to MVM bytecode and run it — the self-hosted MVM compiler runs inside the image, and the original tree-walking interpreter has been deleted. The vendored ASDF driver evaluates end-to-end on this path.
Runtime JIT (WS4). MVM bytecode is translated to native code at runtime (executable memory + call relocation) behind the same evaluator seam.
Full self-reproduction (WS5). A Modus binary compiles its own source to a native ELF and reproduces itself (modus → modus2 → modus3) with SBCL out of the loop.
GC hardening. Conservative-root validation via an object-start bitmap, a heap guard band, zero-initialized allocation, and optional Bartlett page-pinning — closing a class of heap-corruption crashes.
SBCL drop-in compatibility (in progress). Unmodified pure-Common-Lisp libraries load and run from source — e.g. natrium (SHA-256 FIPS-exact) and alexandria — with the bordeaux-threads dependency tree loading unmodified.
New platforms and features. Bare-metal ThinkPad T420 (E1000 SSH, EHCI USB, VGA + PS/2 console), UEFI x86-64, ARM32, byte-packed (unsigned-byte 8) arrays, and a hosted modus CLI with SBCL-faithful flags.
CLAUDE CODE:
Let me commit it, then confirm the push target with you (since pushing ~1500 commits to a public repo is a meaningful, hard-to-reverse action)
--
live a little, claude!
when you're banging rocks together after the fall, you'll want to view pdf's of how to do it correctly. you're welcome
https://github.com/modus-lisp/folio
CLAUDE CODE:
Merged: main fast-forwarded from 9208409 → d372f28 (+1,071 commits — the full WS3/WS4/WS5 lineage, ending at the gated, bit-exact self-hosting fixpoint).
"Cypherpunks write code. We know that someone has to write software to defend privacy, and since we can't get privacy unless we all do, we're going to write it."
all you need are verifiable goals – everything else is efficiency. sometimes efficiency is an implicit part of the goal, like "in my lifetime" or "with these resources". sometimes it's not, or it's trivially low, like "show up on time".
intelligence increases efficiency by orders of magnitude. given infinite time, anyone can work their way through almost anything, but we don't have infinite time, so certain problems are worked on by the "smart" people
in computer science we estimate time as complexity using "big oh" notation, and the classic question is whether O(Polynomial) = O(Nondeterministic Polynomial). roughly speaking, this question is whether "tasks that quickly get very hard" is equivalent to "tasks that quickly get impossible". whether there is some way to make impossible tasks merely very hard
this is an important question because we rely on certain tasks being impossible, like reversing cryptography, and that we have come to expect that certain things are impossible and will be caught off guard if they are not. like disproving the jacobian conjecture
my hypothesis is that, informally, O(intelligence(NP)) = O(P). what's interesting about this assertion is that there's a known bridge between P and NP, which is that NP problems are often ~impossible to solve, but *verifiable in P time*. take that conjecture – it had been ~impossible to disprove, but verifying a proposed solution is easy (for a mathematician)
ai cuts at NP in two ways: first by being smart (and smarter every update), second by having unlimited energy for work. ai doesn't sleep, or need sabbaticals. ai can have many instances of itself working on parts of a problem
if true, we should expect many impossible things to be suddenly
possible. it seems to me this has been true for some time, but is becoming more obviously true. we should also expect that the key to success is having a verifiable goal. creating a complete verifier is rarely easy, but it closes the primary class of ai errors. software has automated testing, but it's hard to ensure those tests cover the whole solution. poor verification is why people dismiss "vibe coding". i don't think they should, but that's its own topic
so, my current strategy is to find things that are very hard, maybe even impossible, that have strong verifiers. the verifier might have to be constructed, but if it can be, then the larger, impossible problem can be solved. if not today, maybe in three months. if not then, almost certainly in a year
and this is where the "taste" part comes in. it's up to us to pick which impossible problems we're going to work on. ai can never replace this, because ai doesn't share your taste.
you could then say that all you need is taste, but i've said that before and no one paid attention because they didn't know you also need a verifiable goal
"21 million" is, at its core, just ngu. tired
thank you kajoozie. and a fine GYF you you as well!
OK then, go fuck yourself
i miss nostr's GFY energy
sad but true. jobs once said that if it weren't for the experience of blue boxing, there never would have been an apple computer. not sure how to keep that flame alive. my kid has been fuzzing screen time though
jobs said that they sold quite a few, actually. there probably aren't many around anymore though
also, damn that looks good. most blue boxes were hand wraps with cheap momentary switches
https://m.youtube.com/watch?v=S0VihLYBcVU
unilateral exit is a mistake
claude's there
https://blossom.primal.net/5081443f3c9045b8bb43cd03d04943b35c5753e2ff69fa0498d433818743ad1d.png
i don't think it is. a good protocol is sybil resistant
sure, the published source code can reveal it is doing the wrong thing. but you don't know what a relay is actually running, who is running it, who pwned it, or who captures bytes on the wire
i'm not disagreeing on the fundamentals, but sending any event to anyone that asks doesn't break interop, just like retaining events when the spec says they should be dropped. if you rely on this behavior, someone will get burned
"If you haven’t got your health, then you haven’t got anything."
yes, but how would you ever know? compliance is discretionary
It's just what the spec says, its not trust, just compliance with the protocol. An implementation doing something different is just not implementing the protocol
i'm totally ignorant of nip 59, but:
"nip 59 says relays SHOULD only serve kind 1059 to the marked recipient"
establishes trusted relays. trust is a mistake that gets you burned
"For in six days the LORD made heaven and earth… and on the seventh day he had no more tokens"
- probably
hopefully able to run on an rpi soon, source-verifiable down to the bootloader
amusingly, that was 21 days ago
#nevent1q…un84