burntcaramel
It’s the exact same wasm as the cli command above.
I can take a screenshot if you need.
npx qipgui qip.dev gui/openai-anthropic-arr.wasm
Project Sync: The journey to sample-perfect audio/video sync with WebCodecs
Apple is finding its voice for what more sophisticated multitouch UX can be
You can also run the same wasm on the command line:
npx @qip.dev/qipx qip.dev run \
image/webp/webp-to-ktx2-r8g8b8a8-srgb.wasm \
image/ktx2/ktx2-r8g8b8a8-or-b8g8r8a8-srgb-to-png.wasm \
< input.webp > output.pngAnthropic warns of 'existential risks to humanity' in IPO prospectus
- WebAssembly: 4 float32s
- Mojo: N float32s where N is a compile-time parameter
- Go simd: vector of float32s
Back and shoulder surgery is often worse than useless
https://www.economist.com/leaders/2026/09/24/back-and-shoulder-surgery-is-often-worse-than-useless
https://archive.ph/j6oeD
Australia's giant data-centre boom
Show HN: JavaScript syntax highlighter in 12.7kB of WebAssembly, Shiki 99.9%
It me you think “ok, how big do I want the maximum image to be?” I’ve settled on 25 megapixels, which in the hundreds of megabytes. Since most images are much smaller, I believe on all mainstream hosts the memory isn’t paged in until it is first read/write so the memory footprint is much smaller.
Combinatorial Implosion
Faster pull requests are faster horses
A compiler promising source stability is a different commitment than the compiler’s code being ready for outside contributors. Which is also different to having ABI stability, which took until 5.0 for Swift to achieve (I think Mojo does not have ABI stability as a goal as it doesn’t have to link to OS frameworks).
I agree with some of this post but the argument feels muddled. "Clicking a logout button navigates the current page to a logged-out one" is wrong — it changes the state of the session, which is more than just a navigation. "Relative links can jump around the current page" — this _is_ a navigation.
I too weighed up the differences between a button and link and referenced the now sadly defunct WAI-ARIA Practices document which I found pretty clear: https://components.guide/accessibility-first/navigation
Part of the understanding that is missed being learned by the team are the failure modes: how can this system fail and how catastrophic is it?
Now I fear only the users will learn via data loss, leaks, and hacks.
Agents of Our Own Illiteracy
Rise of the Gen-Z Luddite
Carson Block: If you thought the global financial crisis was bad
It can feel super useful as an engineer to find a line of code in PR or a sentence in a Notion document, and then add your feedback directly there. But then I find the conversation half happens on Slack, and then continues in a Zoom meeting, and then the comment on the Notion doc is out of date. So I have to keep track of all of this in my head with which piece of feedback is stale and which one is still relevant, and then reconcile that with feedback from others.
It’s assumed that we need another tool, something that can do the job of retrieving all of these comments and reconciling them into a total order. My article asks whether reconciling decisions into a total order is actually part of the job of leadership. If we defer to AI to make sense of what we’re saying and deciding then we risk the people and the org becoming weaker from lack of clarity.
Death by a Thousand Comments
Full test coverage doesn’t tell you if the tests behave correctly. So you could prompt an AI agent to write 100% test coverage where those tests could be exercising all code paths yet contribute 0% to the story of what the code does. You need human understanding of what the desired contract is that the tests check.
Imagine a contract lawyer who blindly signs any contract that they are given: they aren’t doing their job. They ought to have an idea in mind of what their client’s goals and limits are so they can determine if a given contract fulfils those needs.
Types are a declarative contract, so they can be a lighter yet more limited way to enforce a contract. The compiler can verify if all the declared types across the program agree with each other. This is especially helpful with refactoring, such as ensuring the adding a field has been rolled out everywhere.
Types aren’t to be just checked by the compiler, but checked by the human authors too. That’s why explicit type signatures are valuable, especially if they are kept intelligible. They encode the different variations in state and possible branching on that state. So you can whittle your types down as a way of whittling the solution down to be more focused. The problem in your head is reflected in the types, and any simplifications in the types then simplify the problem in your head, and any tests derived from that understanding.
Yes, accessibility is a key concern of mine, I’m keen to explore html-in-canvas as a way to have an accessibility tree combined with a rendered interaction.
I’m personally at a stage where React and CSS have pushed to DOM to extremes of complexity and difficultly in optimization that I desire simpler ARIA-based HTML combined with custom rendering. I’m hopeful that it will be easier to test, lighter for users, and faster for everyone.