Hacker News new | past | comments | ask | show | jobs | submit
Agreed. I started writing a desktop GUI harness in Rust using native desktop GUI APIs.

Claude, Codex, Opencode, everything is Electron. With agents and solid engineering fundamentals, I set out to prove that we don't need to take that shortcut any more and we can, in fact, ship high quality/performance applications.

It's still early days - but I got something basic working. I've embedded the Goose harness as a back end and am using the UI framework used by the Zed editor.

https://github.com/alshlabs/quill

I'm keeping the source closed for a little while. Also if anyone from the major labs is hiring, hihi, I make quality things.

Also I'm aware that this is a rip off of vscode's design. I like their UI, lends itself well to projects and so on. In a different life I might have ported vscode to Rust - but no one uses IDEs any more haha

I'm sorry and will be the first to admit I went for this too, but "using agents to write more tools for agents." is literally the problem.

The purpose of software is to help people with their problems. I think it's easy to tell ourselves that other people want to use our tools which we really made to help ourselves (especially if them using it also helps ourselves even more!). And also, this is all so new and there are real opportunities that it is good to learn and try new things and be open to actually making something valuable.

But! Other people extensively using agents are literally the last people who would pay for a project like this! And unless it's a fulltime job like it is for a 5 or so well resourced tech companies, it's hard to make something as good and useful as them. I say this as someone who spent a long time on this problem as my fulltime job.

We should still have fun with our work. But literally, "software for other software people, that solves the problem of us needing to write more software for writing software, faster", who is that helping? There are no constraints or end users besides ourselves, and half of that is not so much it benefiting us through productivity, but learning new things and play - again, important. But there's a reason so many people are doing this and I think it's because they don't have to go outside and solve someone else's problem, or do something unusual, or involving unfun non-software aspects - agents are fun! But how many random people's agent have you installed?

IMO: if the technology does not help a non-technology person live a better life, and especially if it involves "using an agent to build a framework for agents" we should do some more, deeper introspection about what problem we are actually solving and whether or not we're being ambitious. And I say that not to pick on you but myself.

I really love your viewpoint. And I also see that around me a lot of people developing their own custom stuff that fits to their way of thinking, but not apt to others, so everyone developing their own custom. It is fast an cheap, exciting and comfortable. I am a bit puzzled as I see hyperpersonalised sw is a way to divide us and put us in an echo chamber. No need to understand how others work or think… And we loose our knowledge that is comming from the experience of interacting whit other way of thinking.
I see your point. In this case I'm intentionally reinventing the wheel for the sake of correctness and quality.

For the end user, the outcome will likely be the same when compared to opencode or similar, but the journey will be nicer

I expect no one to actually use it though, however nice it might be to hope for that

loading story #50229830
> Naturally, game engines are crazy optimized, so the UI runs butter smooth and uses pretty much no resources.

We should build everything using a AAA FPS engine loop now that we can. The amount of shit that happens in one rendered frame of overwatch is wild. And then we go and do like 200 of those per second.

Yeah but it’s okay if overwatch takes all of your computer’s effort to run. Imagine if postman used 13 gb of vram
If your program does 1/1000 of the GPU work Overwatch does every frame, it will cost in the order of magnitude of 1/1000 of what Overwatch costs to render (some fixed costs aside) -- taking aside the fact that you also don't need to re-render the entire window every vblank.
i mean, sometimes it feels like it does
VRAM isn't RAM. Unless your postman is rendering 3D objects.
loading story #50230320
One recent performance issue that was raised by a customer was in the end a tiny svg animation loop that was on all the time even when the tab was inactive. So no game engine loops for my customers.
SVG animation in a browser works completely differently than a game engine handles animation. SVG is based on the DOM and animating it requires mutating the DOM. Lots of string operations because everything is a string attribute. All of that has a ton of unnecessary overhead.

You actually would have been better off replacing your SVG animation with a game loop! Assuming you're using Lottie you can easily swap it to render into a `<canvas>` which doesn't have any of that overhead and uses `requestAnimationFrame` which automatically gets throttled in inactive tabs.

No you won't. Firstly because your software is one of dozens running and it doesn't get to take the privilege of fucking over my battery consumption and asking for my GPU to spin so you can edit markdown, and also because 2D rendering is miserable and non-performant in every single game engine you can think off. 2D sucks to make, 2D eats half of your frame time by just existing and slicing those triangles.
What?

You can try rendering a 2D rectangle as 2 quads in whatever GPU API you like the most, then try pushing the same amount of pixels to a CPU buffer via the widest CPU memory write instructions you can have (and then wait the GPU-accelerated compositor upload them to the GPU anyways to present them...).

I can tell you for a fact one will be 2 orders of magnitude faster, want to make bet which one?

Using a GPU api does not imply you have to render at the screen's refresh rate, or even that you have to update the entire window.

Rendering the final triangles isn't the issue. The issue is that while your 3D world is nicely setup polygons that benefit from all the culling you can do with it, your 2D UI is requiring vector graphics which your GPU will absolutely hate having to render. The actual composition of the UI elements is incredibly non-performant. Pushing the pixels doesn't matter.

There's a reason why browsers are so complicated and equally non performant. 2D rendering, even GPU accelerated, with the constraints we have right now (or rather, the lack of constraints, because 3D rendering is basically tradeoffs all the time), is not going to be more performant.

loading story #50231564
loading story #50231068
Haha, in my case, it only renders when frames are needed. Otherwise it's basically an image at 0fps.
> Firstly because your software is one of dozens running and it doesn't get to take the privilege of fucking over my battery consumption

This never stopped the Electron devs until now, I honestly can't see why they'd start to get any better now that the slop machine lets them be even lazier.

> no one uses IDEs any more This is false. Plenty of people using IDEs every day
True but the number is also decreasing every day. And I'd imagine that it's decreasing pretty rapidly.
loading story #50231603
loading story #50229724
loading story #50229467
I've been working on using Svelte + Rust to make desktop apps with native UI frameworks [1], resuscitating a COVID era side project that I felt was intractable at the time. I havent updated the docs or README.md so you'll have to point an agent at it to figure it out, but so far GTK/QT are fairly complete and I'm working on WinUI/AppKit.

[1] https://github.com/akiselev/svelters

This is awesome and I'm glad things are moving in this direction. I've been playing with Crux (Rust + Native UI) myself: https://github.com/redbadger/crux