
We Put a Browser in Everything and Called It Progress
We Put a Browser in Everything and Called It Progress
以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。
10 min read
Thursday, October 15, 2026
We Put a Browser in Everything and Called It Progress
The hardware got faster. We lowered our expectations.
Share
Something that has been bothering me for a while is how much waiting we’ve come to accept from ordinary desktop software. You open an application to find a file or change a setting, and first you have to wait for the interface to load, then for it to finish whatever it’s doing in the background before you can actually use it. And even once it’s open, switching to another view can start the whole thing again. I find this incredibly annoying, especially when the thing I’m trying to do is so simple.
What bothers me even more is how quickly we start defending it. Of course it takes a moment, it’s doing a lot. It’s cross-platform, it has plugins, it needs to sync. Yes, I understand all of that, I build software too. But explaining why an application is slow doesn’t make it any less frustrating to use, and it certainly doesn’t mean we should stop expecting better.
Instead, somehow the conversation ends with the user being told to disable features or buy more RAM. We all have pretty powerful hardware these days, especially compared to what we used to work with. Even a fairly ordinary computer has capabilities that would have seemed ridiculous twenty years ago. So why do I still find myself waiting for it to show me a folder?
We were already editing documents, managing files, listening to music and switching between applications on single-core machines with a fraction of the memory. Those computers had plenty of problems. I don’t miss waiting for a hard drive to finish making noises before I could do anything, and I’m certainly not asking for Windows XP back. But opening a local document wasn’t some ambitious goal we were hoping future hardware would eventually make possible. We could already do that.
Now we have faster processors, more memory and SSDs, yet some applications still struggle to let us move between a few views without stopping to load something. Or they make opening a file we already have depend on a service we can’t currently reach. We’ve gained an enormous amount of capability, but we’ve also managed to make some very ordinary tasks more complicated than they need to be. That’s the part I have trouble calling progress.
Putting a browser inside the application is a particularly good example of that tradeoff. We get familiar tools and an interface we can ship across several platforms, which is useful. Modern applications also do things their older counterparts couldn’t, and I want those things too. But adding collaboration or syncing shouldn’t mean giving up on opening a menu promptly. Somewhere between choosing the stack and handing the application to the user, we still have to make it pleasant to use.
I don’t expect every operation to finish immediately. If I’m compiling a project or exporting a video, I know I’ve asked the machine to do some work. I can let it finish. What I find harder to accept is having the same feeling of waiting while doing something as ordinary as moving around the interface.
You open a folder, switch to another view and try to bring up a menu, and each step has just enough hesitation to make you wonder whether the click registered. So you click again, which naturally works just as the first click finally catches up. Now you have to undo whatever that did before you can continue. None of this was the task you sat down to do.
And no, I don’t need to prove that this costs me forty hours a year before I’m allowed to dislike it. A door that sticks every time you open it is annoying even if you eventually get through the door. You’d fix the damn thing. You wouldn’t explain that the hinges made it much easier to manufacture.
This is also why an application can have perfectly respectable average timings and still be annoying. The occasional freeze is enough to make me hesitate the next time. Startup, navigation and stalls during background work all need attention; measuring one doesn’t tell us how the rest of the afternoon feels. A screenshot of Task Manager certainly won’t settle it either.
To put some numbers around that, the web has a useful metric called Interaction to Next Paint. It looks at the delay between an interaction and the next paint, including the wait for the event handler and the work it does. Its guidance puts good responsiveness at 200ms or below.
That doesn’t mean anything under 200ms is invisible to humans. It also doesn’t mean every button and menu gets a 200ms allowance before anyone is entitled to complain. I want the whole sequence of using the application to feel good, not just its individual interactions to scrape through a threshold.
For some scale, a 60Hz display has a refresh interval of about 16.7ms. Two hundred milliseconds spans roughly twelve of those intervals. That doesn’t mean every application must complete every task in one frame. It does mean that calling 200ms practically instantaneous skips over a lot of opportunities to show the user a response.
The useful question is what needs to happen before I can continue. A scan might take seconds, but does opening the menu really depend on finishing it? If we can acknowledge the action and leave the rest of the interface usable, we’ve already made the wait less disruptive.
I’d like that work to get the same attention as another feature in the sidebar. Making the application stay responsive improves every visit. It shouldn’t have to wait until we’ve finished all the supposedly important work and can finally afford some polish.
Electron brings Chromium’s process model into the application, with a main process and renderer processes for its web content. That buys you a capable platform: layout, rendering, accessibility machinery and a familiar environment for building interfaces. I understand the appeal. I’ve written plenty of web applications.
That is a lot of functionality you don’t have to build yourself. It’s also a substantial platform to bring along, and you still need to decide what the application loads, keeps in memory and does while the user is trying to interact with it. Knowing how to build a web interface doesn’t automatically answer those questions for a desktop application.
Great. I want software on Linux too. But cross-platform doesn’t answer the question I asked. Does it respond well? Can I use it on a modest machine with my other applications open? Does it still feel good once I’ve accumulated a few years of files or messages, or did we only try the empty account on the developer’s laptop?
Those are questions about how we built the application, and buying a machine with more cores won’t necessarily answer them. Work blocking a UI thread still needs to be moved, reduced or postponed. An expensive laptop can’t make that architectural decision on our behalf.
Electron’s own performance guidance explicitly warns against blocking the main and renderer processes. It discusses deferring work and prioritising interaction, including the example of showing an editor’s text before doing syntax highlighting. The people maintaining the framework know responsiveness requires deliberate decisions.
That makes it difficult to accept “it’s Electron” as either a complete diagnosis or an excuse. We need to look at what we’re asking it to do, particularly when local interaction gets tied to work that could have happened separately.
Take an application that’s downloading or synchronising files. Obviously the transfer needs a connection, and there may be work I can’t do until it finishes. But I’d still like to browse files that are already on my machine, look through content the application has cached or open its settings. The fact that one operation is waiting shouldn’t automatically make the whole interface wait with it.
This is part of what I expect from installing an application. It lives on my computer, so use that to give me something I can work with while the rest catches up. I downloaded it, gave it disk space and let it sit in the tray. Surely we’ve reached the point in our relationship where it can let me open my own files without checking with headquarters first.
There are real engineering problems behind doing this well, especially with collaborative data. I don’t think they’re trivial. I think solving them is part of delivering a good desktop application, and wrapping the web version doesn’t make them disappear.
And before this becomes a recommendation to swap frameworks and declare victory, I’ve made the same kind of mistake without a browser anywhere near it. I build zenkai with Zig and Qt, and I still put a deliberate wait in front of the user because I liked how a fade looked.
In my performance measurements, the Linux build reached its window paint handler at about 47ms with animations disabled. Turning the fade on barely changed that marker, but the window didn’t reach full opacity until about 270ms. These measure paint entry and fade completion, not when the monitor presents the pixels, but they were enough to show where I’d deliberately added a wait.
I could have rewritten the whole thing in assembly and still spent 200ms fading it in. The computer was doing exactly what I told it to do. Unfortunately, what I told it to do was take longer.
That experience is why I care about measuring the behaviour rather than congratulating myself on the language I chose. A native toolkit can give you a different set of costs and capabilities, but you can still use it to build an interface that gets in the way.
But please don’t turn that into “everything can be slow, therefore the choice doesn’t matter.” Of course it matters. If I’m building a small local utility, bringing a browser runtime along is a decision I should be able to justify. “I know this stack” is an honest reason to consider it. I just need to check what that decision costs the person who runs the thing.
I like C++, but I’m not going to prescribe a rewrite every time a button takes too long. Start by finding out what the application is doing. If the UI is waiting on work that doesn’t need to finish yet, fix that. If your choice of framework makes the experience you want impractical, then yes, reconsider the choice. Neither answer should be off the table just because the team already knows the stack.
That investigation needs to happen under conditions that resemble actual use. Put some data in the project, leave the other applications open and try navigating while background work is running. Look at the slow cases as well as the average. We shouldn’t need a user to explain that the application behaves differently once they’ve started using it properly.
And when somebody says the application feels slow, take them seriously. They don’t need to identify the blocked thread before the complaint counts. Most people aren’t going to attach a flame graph to “opening my project takes forever and the menus keep freezing.” They will just stop enjoying the thing, and eventually stop using it if they have a choice.
I want useful features and software I can run on all my operating systems. I also want it to keep up with me. Electron may be a sensible way to deliver that, but choosing it doesn’t entitle us to treat the everyday experience as somebody else’s problem.
That’s what I want all this better hardware to buy us: more room to do useful work while the ordinary stuff stays easy. Keep the collaboration, the plugins and the features that would have been impossible on those older machines. Just don’t make me miss how little fuss it used to take to open a file.
We put a browser in the application because it solved problems for us. Whether that was progress for the user depends on what we delivered. If they’re still waiting for a sidebar to load on a machine that can edit video, I think we owe them a better answer than “have you considered more RAM?”
Thank you for your time and patience reading this article
正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。