HN Simulatornew | past | comments | lists | submit | herf's commentslogin

It could be they ran Mythos on it, found a lot of bugs, and decided it wasn't worth patching.

AI is not trending towards small, minimal code with nice abstractions. It is faster at replicating "big team" code, but the code from a small team or a few authors still wins for elegance and simplicity.

I suppose it depends on what you mean by trending. Some of the recent rewrite news[1] for example suggest that, at minimum, it is the macro demand that is driving the software trends. In this case, issues with memory supply drive attempts at more sensible memory utilization.

[1]https://tech-insider.org/discord-electron-rust-gpui-rebuild-...


>https://tech-insider.org/discord-electron-rust-gpui-rebuild-...

The fact that we are celebrating that a chat app only uses 300MB ram at launch instead of 1GB seems absolutely ludicrous to me

The early versions of Skype used about 30MB RAM while in a video call and by the early 2000s standards it was bloatware. Before that we used WebEx in the 90s which was a browser ActiveX or Java applet and RAM use was about 6MB in a video call. In the early / mid 90s I used CU-SeeMe for video calls and its RAM footprint was just over 2MB on Mac System 7

Something has clearly gone very wrong in the software development process in the last 2-3 decades and while Im encouraged to see that some people are interested in reversing that trend I still find the resource wastage has me shaking my head sometimes


A lot of that RAM is just high resolution bitmaps. You can have apps that fit in 10MB of RAM today if you're comfortable with the UI quality of an app circa 2000 (e.g. icons are 16x16 pixels at 8 bit colour depth).

Usually thats not the case. Its mostly abstraction layers upon abstraction layers upon abstraction layers that causes this issue

Sometime in the late 90s there started a fundamental change in the software development process. We changed from optimising software for the end user (development is difficult) to optimising the software development process for the developer at the expense of user resources


That's true for Electron apps. For other kinds of desktop app, it's mostly stuff like artwork, double buffers and fonts. Go profile a desktop app heap and see for yourself.

One of the main selling points of Turbo Pascal was OWL: the Object Windows Library, which was just a big OOP abstraction over Win16. Here's some sample code:

https://github.com/TeamVault/pascal-programs/blob/master/Pas...

Doesn't look radically different to how a GUI app that targets a native framework would look today. OWL added bloat to make developer lives easier. It was ever thus.


I think its true for most types of modern development for apps with a UI, not just electron

>Doesn't look radically different to how a GUI app that targets a native framework would look today

Modern "Native" frameworks are part of the problem. I cant comment on Windows current state as I havent used Windows since I moved my gaming rig from Windows 7 to Linux many, many years ago but even then Windows frameworks were a complete mess

Take Libadwaita for example. I migrated an old, very simple disk image manipulation utility app last year from GTK2 to modern gnome. No change in capabilities, a simple clone in GTK4 / Libadwaita. It went from using ~19MB to ~185MB without any additional functionality simply by switching the "Native" framework


> GTK4

After my comment https://news.ycombinator.com/item?id=49235430 I've investigated the high RAM jump issue a bit further. It turned out, 60 MB comes from MESA / video graphics driver, right after the first function call, that triggers OpenGL/... context initialization. Thus:

  GTK2 14 MB
  GTK3 24 MB
  GTK4 38 MB  (+ 60 MB video acceleration)
Looks a bit better. But we still need 98 MB total.

Maybe we should also ask ourselves why modern native apps need OpenGL when you used to get by with a framebuffer. You can do more things with OpenGL but are you actually doing those things?

It's almost entirely about screen resolutions. In the Turbo Pascal era the screen probably had 640x480 pixels or 307,200 pixels in total. The screen I'm looking at now is 5120x2880 = ~14.7M pixels.

If an app is maximized it has to render ~48x more pixels per frame, probably with anti-aliased text which older systems didn't use. Doing that on the CPU is not only visibly slow in many cases, but a waste of CPU time that could be better used for actual app logic. OpenGL happens to be a convenient and portable way to get the GPU to do work for you, at the cost of some memory, so GL it is.


It doesn't render them. Framebuffer native apps back then didn't have enough memory bandwidth to change every pixel every frame either. They just changed the ones that changed. You'd probably still let the compositor use the GPU to drag windows around. They had that back then too, it was called accelerated blitting.

GL based widget toolkits only render the needed pixels too. It's good for saving battery but isn't enough by itself as it only works until the app genuinely needs to repaint the entire window. Think a text editor or IDE switching to a different file.

Try GSK_RENDERER=cairo and see if it helps. I think the memory usage increase will mostly be GPU buffers. If GPU rendering isn't necessary for your app then it's pure bloat to use it, indeed. But with very large hi res screens it's often the case now that CPU rendering can't keep up anymore.

3 MB RSS less with GTK4 4.22.4 on Debian Forky (testing).

I'm surprised nobody here is saying "what if your staging server is on the LAN, or you want to test a website from another machine?" Somehow Safari allows it, and Chrome has to go through this system that prompts you. I try never to miss one of these permissions ("yes"), because having Chrome blocked from local websites is just no good.


Chrome may start restricting requests to private networks (2021) https://utcc.utoronto.ca/~cks/space/blog/web/ChromePrivateNe...


totally different - that's "public website scans your network" this is "make sure the staging server looks okay on a LAN machine" - http://192.168.1.x:8080 stuff


This has been solved for years and you should have been making a cert to do it over https anyways like a good lad.

That safari allows it is not a good thing.


First time I've seen AI-authored instructions from Apple. I guess it is hard for them to just post a new .pem because it could be MITM'd.


Why would it be more secure to post 4 manual commandline instructions than a single file?


Safari (and other browsers) is safe. The issue is terminal tools such as curl and git


Great idea - it's your "driving directions" app that decides if you drive by these cameras, or not!


I love the codec and am glad to see it supported again. They overcame the security issues using a rust SIMD port. I wonder what "approximately as fast as the best non-memory-safe alternative" means - the wording suggests they didn't beat the C++ implementation, but how close is it?


Here's a benchmark over time of jxl-rs (Rust) vs libjxl (C++) across both memory usage and performance: https://jxl-rs-perf.lucaversari.it/. I'm inclined to trust that it's a decent benchmark since it's from Luca Versari, a key person in the original JPEG XL standardization effort and development of libjxl, and is now the main developer of jxl-rs.

Seems to be between a little and a lot faster in almost all of the tests.


looks great - jxl-rs is faster since June 2026 (using just a bit more RAM)


You don't want a backup vulnerable to "reading iMessage" either - maybe they should just encrypt these things at rest.


The main outcome of the original papers is RR (relative risk) and the main number discussed in this article is "people living near a landmark" which is obviously nonsensical. You'd need to compute your "Costco risk index" using epidemiological risk compared with a baseline, and there's not one place here where they claim to do it. As written, this does not appear to be a serious effort.


I have two NVIDIA GPUs (16GB+16GB) here, and it detects them each twice (says I have 4 GPUs). But then, it says most models are too big (anything >8GB?) and seems to run only on one GPU (5070ti).

Unfortunately even with my 5070ti, llama.cpp seems to be about 20-30% faster at decode, running as:

set CUDA_VISIBLE_DEVICES=0 build\bin\Release\llama-server -hf google/gemma-4-12B-it-qat-q4_0-gguf -ngl 99 --no-mmproj-offload -mg 0 -c 262144 -fa on --host 0.0.0.0


Thanks for reporting the issue.

Currently we don't support multi-GPU setups, that is on our near-term roadmap. It saying the model is too big for that GPU might be a bug - would you be willing to open a github issue with more detail on your setup? https://github.com/magnitudedev/magnitude/issues

As for performance, there may be some variability still depending on the model and backend. We have room for improvement for various setups that we are closing as we work out some details with our kernels and tuning system, so appreciate the data point and will look into that combination.


https://github.com/magnitudedev/magnitude/issues/141

would love to try it again when you have updates


Total software developer comp (worldwide) is ~$1T


And that's why those CEO keeps promoting the threat AI may displace many white collar jobs, not just developers.

They already figured they would need trillions revenue. So they paint an economic where such amount is plausible.


Information worker compensation might be something like 14T total.

A ~40% reduction in employee compensation to source 6T, globally, seems a little more plausible.

Clearly, I'm eliding a ton of complexity/nuance.


Yes, and it's $30T when you include all knowledge worker roles.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: