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.

Here’s an example of Sudoku running in WebAssembly (it was vibe coded in Zig) and then rendered to canvas. The interface between the wasm module and the browser is function calls for keyboard and mouse events, and then another that renders to a pixel buffer to copy to the canvas.

https://qip.dev/play-sudoku

And this approach also works for simple forms, such as a URL input that gets turned into a QR code. Again the interface is simple, here converted a URL into SVG markup. As you type in the input we call the WebAssembly render function again.

https://qip.dev/qr

The purpose of a scripting language was to make authoring easier, but now it’s mostly a middle layer. There’s still getting the investment of a great standard library to keep you on track, but if you pick parts to make modular wasm and which parts to use reliably, proven code you can find a good balance.

For qip I chose to use Golang as its standard library is batteries-included with fs & networking.

Then everything else is AI-coded wasm plugins.

https://github.com/royalicing/qip

Comments URL: https://news.ycombinator.com/item?id=47960286

Points: 6

# Comments: 0

qip lets you write tiny WebAssembly modules in Zig or C and compose them together. The modules have a simple input -> output interface and cannot access anything else, no file system, no network, no env vars, not even the time. You chain modules together so the output of one becomes the input of another e.g. there’s a CommonMark module that converts to markdown-to-html. There’s a file-based router that lets you serve a website with these same modules.

I want these modules to be open and shared, so you can decide to have a `/view-source` page that lists all the wasm modules and all the source content (markdown, images, etc) and source code (zig, c). So you can choose to fork the ingredients of the qip website if you like: https://qip.dev/view-source

I chose wasm because it’s fast, runs anywhere (browser/server/native), and has a strong yet lightweight sandbox. I’m working on collaborative web hosting that I hope will bring back web 1.0 vibes.

https://github.com/royalicing/qip

Who gates access to the circle? Anthropic or existing circle members or some other governance? If you are outside the circle will you be certain to die from software diseases?

Having been impressed by LLMs but not believing the AGI hype, I now see how having access to an information generator could be so powerful. With the right information you can hack other information systems. Without access to the best information you may not be able to protect your own system.

I think we have found the moat for AI. The question is are you inside or outside the castle walls?

This is the approach I’m using for my open source project qip that lets you pipeline wasm modules together to process text, images & data: https://github.com/royalicing/qip

qip modules follow a really simple contract: there’s some input provided to the WebAssembly module, and there’s some output it produces. They can’t access fs/net/time. You can pipe in from your other CLIs though, e.g. from curl.

I have example modules for markdown-to-html, bmp-to-ico (great for favicons), ical events, a basic svg rasterizer, and a static site builder. You compose them together and then can run them on the command line, in the browser, or in the provided dev server. Because the module contract is so simple they’ll work on native too.

Incorrect. You ask the OS for pages. (Golang does internally appear to manage its heap into “arenas”.) On WebAssembly the page size is 64KiB. Window 64-bit it’s 4KiB, Apple Silicon 16KiB, Linux x86_64 4KiB.

https://github.com/royalicing/qip

We have LLMs that generate code but that code should be untrusted: perhaps it overflows or tries to read ssh keys. If we aren’t reviewing code closely a major security hole could be on any line.

And since LLMs can generate in whatever language, it makes sense for them to write fast imperative code like C or Zig. We don’t have to pick our favorite scripting language for the ergonomics any more.

So qip tries to solve both problems by running .wasm modules in a sandbox. You can pipe from other cli tools and you can chain multiple modules together. It has conventions for text, raw bytes, and image shaders, with more to come.

I am excited by the capabilities of probabilistic coding agents, but I want to combine them deterministic code and that what these qip modules are. They are pure functions with imperative guts.

Comments URL: https://news.ycombinator.com/item?id=46954333

Points: 1

# Comments: 0

I made Orb as a DSL over raw WebAssembly in Elixir. This gives you extract niceties like |> piping, macros so you can add language features like arenas or tuples, and reusability of code in modules (you can even publish to the package manager Hex). By manipulating the raw WebAssembly instructions it lets you compile to kilobytes instead of megabytes. I’m tinkering on the project over at: https://github.com/RoyalIcing/Orb

- Which brands do people trust? - Which people do people of power trust?

You can have all the information in the world but if no one listens to you then it’s worthless.

Comments URL: https://news.ycombinator.com/item?id=46623819

Points: 2

# Comments: 0