Not “most”, but definitely a depressing increasing number.

And as I said elsewhere, I do consider Electron to be bloat.

But it’s also worth discussing Electron as an entirely separate topic because it’s a huge jump in memory requirements from even “bloated” native apps.

This I think is a core part of the problem when discussing sizes from C64 era to modern applications:

1. You have modern native apps vs Electron

2. Encryption vs plain text

3. High resolution media vs low resolution graphics and audio

4. Assembly vs high level runtimes

5. static vs dynamically linked libraries

6. Safety harnesses vs unsafe code

7. Expected features like network connectivity vs an era when that wouldn’t be a requirement

8. Code that needs to be supported for years of updates by a team of developers vs a one man code base that never gets looked at again after the cassettes get shipped to retail stores.

…and so on.

Each of these individually can contribute massively to differences in file sizes and memory footprints. And yet we are not defining those parameters in this discussion so we are each imagining a different context in our argument.

And then you have other variables like:

1. Which is large? 5 GB is big by today’s standards but even 5 MB would have been unimaginable by C64 standards and that is 4 orders of magnitude smaller. One commenter even discussed 250 GB as “big” which is unimaginable by today’s standard users.

2. Are we talking about disk space or RAM? One commenter discussed using GBs of GPU memory as a way to save sure memory but that feels like a cop out to me because it’s still GBs of system resources that the C64 used.

3. Software Complexity: it takes a lot more effort to release software these days because you work as a team, and need to adhere to security best practices. And we still see plenty of occasions where people get that wrong. So it makes sense that people will use general purpose libraries instead of building everything from scratch to reduce the footprint. Particularly when developers are expensive and projects have (and always have had) deadlines that need to be met. So do we factor in developer efficiency into our equation or not?

In short, this is such a fuzzy topic that I bet everyone is arguing a similar point but from a different context.