Sources

### Link to sectionBrowser Incompatibilities Not only did **Anchor Positioning** keep its number one spot, but the percentage of respondents citing it almost doubled. The **View Transition API** also climbed to number 3, while **Container style queries** gained a whopping **11 spots** in the rankings. On the other hand, **CSS Nesting** and `:has()` both lost ground, which makes sense since these features are now supported in all major browsers. … ### Masonry Layout ... ### Parent Selector ### Scoping ### Link to sectionOther CSS Pain Points **Browser Support** may still be the dominant CSS pain point in 2025, but the fact that only a relatively small 10% of question respondents mentioned it is a testament to recent improvements in this domain. ### Browser support ### Speed of change ### Excessive complexity ### Safari ### Excessive Tailwind usage ### Debugging ### Hard-to-remember syntax ### Conditional Logic ### Layout & positioning ### Other AnswersAnswers matching “Other Answers” 431 ### Link to sectionFavorite New Feature While `:has()` is still number one, it did lose a bit of ground, as the **View Transition API** and especially **Anchor Positioning** (which gained 8 spots) start seeing wider adoption. … ### My 2025 Pick: The

# CSS in 2025–2026: It’s Getting Too Powerful and I’m Scared #webdev #css #frontend #news ... Ladies and gentlemen, **CSS is no longer the passive-aggressive styling language we used to tame with `!important`** — it’s now *a full-grown adult*, with opinions, animations, and conditional reasoning. Let me walk you through the upcoming CSS features that will either make your life easier or make you question your entire build process. Or both. ## 🧠 1. if() Function — Conditional Styling... In CSS!? This isn’t a drill. CSS now lets you **run IF STATEMENTS.** I repeat: > 🧠 **CSS. Has. Logic.** ``` color: if(prefers-color-scheme(dark), white, black); ``` Welcome to 2026, where even CSS has more decision-making ability than my ex. No more juggling classes. No more writing five media queries just to make a button look like a button. ⚠️ Browser support? Still emerging. But emotionally? I’m already 100% invested. ## 🧱 2. Native Masonry Layouts — Finally, Goodbye JavaScript Hell You know that Pinterest-style layout we all love but secretly hate to implement? Yeah, it’s going native. ``` .container { display: grid; masonry-auto-flow: column; } ``` No more **Masonry.js**. No more weird layout bugs. No more “Why is there a gap here that I can’t explain?” This feature is currently in **Chrome Canary and Firefox**, but in my heart? Fully deployed. … ## 🌀 5. Scroll-Driven Animations — Finally, Scroll Magic Without JS You scroll. Things fade. Things fly. You don’t write JavaScript. Did CSS just become... a front-end developer? … ## 🧬 6. CSS Mixins — Sass is Nervous We’ve begged for this. We’ve copied and pasted. We’ve used Sass, Stylus, Less, PostCSS, a handwritten CSS preprocessor made by that one senior dev in 2013… Now? **Native mixins and functions are coming.** … ## 🎨 8. contrast-color() — Accessibility, But Make It Lazy ``` color: contrast-color(background); ``` You know how you're supposed to check contrast ratios, WCAG scores, and make your UI friendly for humans? Yeah, now CSS will do it for you. Because who has time to do math when you're fixing one pixel misalignment for the 17th time? … ## 💡 Final Thoughts So what does this all mean? CSS has grown up. It doesn’t need JS for every little thing. It doesn’t need Sass to feel powerful. It doesn’t even need *you*, half the time. 2025–2026 is the year CSS goes from “styling” to “interface engineering.” So buckle up. Learn these features. Or don’t — but then don’t blame CSS when it leaves you behind for someone with better contrast ratios. … CSS logic might be the one aspect making it a so-called true programming language in a formal sense, but CSS has almost always "had logic". At least since it advanced past simple typography and foreground color styling. Its descriptive selectors and custom properties, also known as variables, and magic idioms for things like the the light-dark mode selection in your first example, have long given CSS (too) much power, and its inconsistent idiosyncrasies have scared developers for a good reason. However, other popular programming languages like JavaScript or C++ aren't much better in that aspect. PixelPerfect Pro • Mar 11 I agree — CSS has had logic for years, just not in a traditional programming sense. Selectors, the cascade, variables, media queries, and now things like :has() already behave like conditional systems. The real challenge is that CSS logic is implicit rather than explicit. You don’t “run” code; you describe constraints and let the browser resolve conflicts. That’s powerful but also why it feels unpredictable compared to JS or C++, where control flow is visible.

The second section of the video I want to call out is the part where Theo links to an old thread from the developer of BoltAI, a native SwiftUI app for Mac that went through multiple updates – and a lot of work on the developer’s part – to ensure the app wouldn’t hit 100% CPU usage when simply loading a conversation with ChatGPT. As documented in the thread from late 2023, this is a common issue for the majority of AI clients built with SwiftUI, which is often less efficient than Electron when it comes to rendering real-time chat messages. Ironic.

It’s also safe to say that not everyone loves it – as demonstrated by the reaction on Twitter. “I’m suddenly in need of a new password manager,” wrote Mac developer Bryan Jones after downloading the 1Password update. Coder Tom Morris said: “It has been a bad week if you like software that is high performance, low memory usage, and not hideously ugly.” Penetration tester Vetle Hjelle put it even more bluntly, branding it “a punch to the gut”. Clearly, some developers love Electron, while many others hate it – but why is Electron so divisive? … “Talk about bloatware,” says software developer Sam Strachan, who points to how two Electron apps he uses regularly – Postman and GitHub Desktop. Both have temporary files that clock in at around a gigabyte each. “In some ways, it just doesn't matter these days, because who notices a gigabyte here and there? But when you stop and think that, actually, you could write the same app [natively], it would be like a couple of megabytes.” There is then a trade-off, as each Electron requires its own Chromium back-end, so if you’re running, say, Slack, GitHub Desktop and Visual Studio Code at the same time, it’s effectively running three copies of Chrome at once. “I usually work with powerful machines so they are not as noticeable, but I can imagine most people with average computers really suffer if they open multiple Electron apps,” says Federico Terzi, a software engineer who’s had his own experience building cross-platform apps such as Espanso, a text expander. Choosing Electron impacts users differently. “I think Electron is mostly loved by developers rather than users,” Terzi continues. ... ## Might Electron pose a cyber security risk? There’s another layer to Terzi’s concerns. He worries Electron apps, by nature, aren’t as secure as native apps, which could have significant implications for apps such as password managers. “The biggest problem with Electron applications is that you build them using JavaScript,” he says. As JavaScript is often open source and used all over the web, the applications are often built using many different packages – building blocks of code that have been written by other people. If you want your app to show a graph, for example, instead of going to the trouble of writing your own graph-drawing code, it’s much easier to use an off-the-shelf graph drawing package inside your app – and that package becomes a dependency the app requires to run. It makes development much quicker, but it does have one drawback. “An average application can download thousands of those dependencies, because each dependency has other dependencies, which each have other dependencies, and so on,” says Terzi. This creates what Terzi describes as “dependency hell”. … ## Money is the main reason Electron is surging Security and bloat aside, Electron is clearly popular. So, what’s motivating the trend for Electron? Why are major apps such as 1Password switching to the framework when there's so many conceivable drawbacks? “For a company, it's a no-brainer to choose an Electron app,” says Terzi. “They can reuse the web developers they have in-house to build a desktop application. And if you go with native applications, the skills that are needed are completely different, and it’s usually harder to find developers.”

## Memory Usage Matters So one thing that's really important with Electron apps is that memory usage matters. We'll put it in big, big, big words. Electron gets, in my opinion, a little unfair rep about using too much memory. People get a little grumpy about it. They're like, “oh my, you know, A95.exe only used one MB of memory, and it did all this stuff. Why can't Electron apps in 2018 use that?” It's mostly nonsense, but they see a number and they get mad about it because of this. … So even though we've got this amazingly fast network and we can load all this stuff really fast, the flip side is that we really care about initial paint. And so anything that gets in the way- the libraries you load on startup will definitely get in the way of that. So it's also bad for memory usage because Node modules never get unloaded. So once you load them they're stuck. There are some clever hacks you can do to kick it out of memory, but those are taking over the Node module system. In general, libraries, once you load them, they're loaded. … ## Don’t Run Stuff in the Main Process Cool. So performance is cool, memory usage is cool. Another thing that I see a lot of new Electron developers, they're often coming from a web developer worlds. They're not used to native development. Chrome and Electron have this concept called the multi-process model, right? So your program in an Electron app starts off as a Node script, right? … How many people have ever used the remote module? It's really common enroll in Electron. The remote module is a way to access things on the main process from a render process. So it's really convenient. But the problem is it's also really slow because it has to use this synchronous send. It has to wait for a response. It stops the render process, asks the main process a question, gets back a response. And so if you do that once, it's not a big deal. If you do that by accident all the time, like from an on click callback or an on scroll callback, you're going to really grind.

whyI’m betting on web technologies to build user interfaces or whyI prefer bundling a rendering engine. Electron’s choices, especially the very idea of building interfaces with web tech and shipping large parts of Chromium to render them, are not uncontroversial. Reasonable people wonder why we made those choices. ... It tries to pre-empt a lot of common misconceptions. This post is a pairing suggestion—and discusses some of the things I believe people get most wrong about Electron on the Internet today. I’ll admit I’m not a huge Electron fan. Slack’s early years soured me on it considerably. Back then it would regularly use 2Gb or more of RAM, which was outrageous on a contemporary machine with 8Gb of RAM. Nowadays Electron apps are somewhat unavoidable, and seem to be a bit better behaved. Still, there’s no standard UI across Electron apps, and each one bringing 100Mb or more of Chromium along for the ride 1 does not fill me with joy. Ultimately, Electron feels like a tool that’s good for business, not a tool for building amazing applications. Nonetheless it’s interesting to read this perspective on Electron from one of its developers. ... However, the entire point of Electron is that you can pair your web app with any native code you want to write—specifically with C++, Objective-C, or Rust. I don’t think that point is well advertised or a reflection of Electron use in practice. From my experience most Electron apps use JavaScript and web technologies as much as possible, only using native code if absolutely necessary. In contrast Tauri seems to emphasise the native back-end aspect of their implementation quite a bit more. Right on their home page they say:

In this episode of the GitHub Podcast, Abby and Kedasha are joined by Keeley Hammond, a longtime maintainer of the Electron project. They explore the inner workings of one of the most widely used open source desktop frameworks, dive into how Electron empowers developers to build cross-platform desktop apps with web technologies, and discuss what it takes to build a welcoming and sustainable open source community at scale. The conversation touches on contributor culture, project governance, automation tools, and the role of AI in open source, in both its promise and its challenges. Links mentioned in the episode: https://github.com/electron/electron https://github.com/electron/forge https://summerofcode.withgoogle.com/ https://openjsf.org/ https://github.com/vert-d https://www.weforum.org/reports/the-future-of-jobs-report-2025/ https://github.com/electron/governance https://github.com/electron/electron/issues https://github.com/unjs/issue-triage The GitHub Podcast is hosted by Abi...

Electron is a mixed bag. Go online, Reddit, Hacker News, X, or anything public, you’ll see the moment an app is released with the mention of Electron, the pitchforks come out. Sometimes to an extreme. The internet loathes Electron, more so than most tools. Why is this? Electron’s historical usage has been plagued by poorly performing apps. Many apps that are resource hogs you probably use right now. The general level of performance has gone up over the years as maturity rises, but the stigma of poor performance has been attached to Electron for forever. Combined with an echo‑chamber effect, this leads to a general disdain for all things Electron. We as developers understand Electron can be un-performant, can be bad, and can have countless issues. But this can be applied to any set of tools we use, it’s not specific to any one thing. Choose any arbitrary language, framework, or library and the same could be said. An app built with Electron can be the greatest app you’ve ever used, or the worst. … So, why does Electron seem to breed poor‑performing apps? One word: accessibility. We as an industry lack native app developers. For every one native developer, there are eight web developers. If you’re one of the eight web developers looking to build a desktop app, you’re going to choose what you’re familiar with. This accessibility allows so many people to build desktop applications of varying quality. You’re bound to have a ton of horribly built apps, by developers whose core competency isn’t even the platform. Companies looking for desktop apps “for cheap” are going to push their dev teams to choose tools like Electron with no regard for technical effort. Someone out there is saying “we should choose Electron, it’s just building a website, we don’t even need more developers.” This is how we end up with poor performing apps.

eivarv on July 19, 2016 In my experience, Electron apps tend to be bloated, not very performant and/or energy inefficient. This means that developers make a choice regarding users' disk space, user experience and battery life. The extent to which users notice any of this is of course dependent on a combination of their machine (e.g. old/new hardware, laptop/desktop) and the application being run. Also, since you don't use the platform's native widgets, there's poor (or nonexistent?) accessibility features for users with special needs - not to mention the implications (HCI-wise) of redefining/replacing standard interface elements. In my opinion, all this reeks of poor design, and is arguably (in some cases) downright user-hostile and unethical. … Cons: - Memory usage: An Electron app is essentially a fully-featured Chromium browser and a Node process that communicate via IPC. This might be a bit bloated for some applications, particularly if you're targeting systems where memory is limited. - Large builds: Packaged Electron apps contain everything they need to run so they're typically quite large. Don't be surprised if your "hello world" app ends up being over 30MB. - Not truly native: Sure, you can make your app look great but the only way you can make it look 100% "native" is to use the widget toolkits of whatever operating systems you're targeting. Electron does not give you access to this. - The DOM can be your worst enemy: This is where the performance issues of many Electron apps (Atom comes to mind) arise. Depending on the complexity of your app, you'll want to either limit how many elements you render to the page at any given moment or look into using something like HTML5 canvas to render. … But the idea of using a fucking gigantic framework (I mean think about it, just Electron by itself is all of Chromium basically, or at least the big complicated exciting bits) is a massive code smell to me. It's like using an ORM or a heavyweight web framework: whenever you're leaning on that much code just for your baseline of functionality, you're making a lot of assumptions that should, as a developer, at least give you pause. … In my experience, Electron apps tend to be bloated, not very performant and/or energy inefficient. This means that developers make a choice regarding users' disk space, user experience and battery life. The extent to which users notice any of this is of course dependent on a combination of their machine (e.g. old/new hardware, laptop/desktop) and the application being run. Also, since you don't use the platform's native widgets, there's poor (or nonexistent?) accessibility features for users with special needs - not to mention the implications (HCI-wise) of redefining/replacing standard interface elements. In my opinion, all this reeks of poor design, and is arguably (in some cases) downright user-hostile and unethical.

Building cross-platform desktop apps with Electron is easy to get started with. But as your app grows in scope and complexity, you will likely encounter challenges around performance, memory management, debugging, and distributing native addons. In this comprehensive 4000+ word guide, I will share techniques and best practices I‘ve learned for tackling these pain points over years of experience as a full-stack developer building Electron apps. … ## Scaling Electron Apps with Multi-Threading Perhaps the biggest challenge with Electron apps is blocking the main UI thread with long running tasks like processing data, calling APIs etc leading to frozen apps! So how do we run JavaScript code across multiple threads? ... … Common causes of memory leaks: - Global listeners not cleaned up on window close - Closures maintaining references to large objects - Accumulating UI element handlers without releasing Apply fixes like: - Carefully removing unneeded references - Throttling activity for intense operations - Pooling + reusing objects instead of allocating more With good practices, Electron apps can have great memory performance! … ## Mitigating Key App Issues Beyond previously mentioned tips, some other common issues you may encounter: ### 1. CPU Usage Spikes This usually happens when loading large amounts of data on renderer process. Fix by throttling + batching using `setTimeout()` or dedicated worker threads to import data. ### 2. High Memory Usage on Main Process This points to architecture issues like business logic in main process. Refactor code to leverage renderer processes better. ### 3. Window Freezing on Load Heavy UI work during component mounting can stall main thread. Use `useLayoutEffect` carefully to avoid blocking first paint. ### 4. Node + Native Module Incompatibilities Rebuild native modules after Electron upgrades using **electron-rebuild**. You can leverage these diagnoses + mitigation strategies to drastically improve app performance! … ### 3. Windows defender or antivirus blocking app This is common during development. Disable them for app folders temporarily. For production, consider code signing certificate to avoid false positives. ### 4. App crashes randomly Leverage **crash-reporter** to log errors to hockeyapp or server to debug later. Also use React error boundaries wrap around app entrypoint to prevent renderer crashes from breaking app. Hopefully these tips help you mitigate frustrating issues that come up down the line!

- **High RAM consumption**: Electron apps tend to use a minimum of 80 MB of RAM, with lightweight apps in the 130-250 MB range and monsters like Slack sometimes reaching multi-GB values. - **Large storage footprint**: Shipping with a full Chromium runtime, you can expect most Electron apps to consume *at least* 150 MB of storage. - **Slow**: Some Electron apps are definitely slow, but that can depend on many factors. Overuse of animations, for example, can substantially increase the CPU usage and thus make the app feel slower. Did you notice that most desktop apps that feel snappy don’t include any animation? Just because you can with Electron, doesn’t mean you should. - **Lack of native UI/UX**: Electron renders webpages and not native controls. On one hand, that gives complete freedom to designers, but on the other, the app looks different from the “native” ones. Unsurprisingly, this complaint usually comes from macOS users, where a single “native” framework exists: Cocoa. Due to the fragmentation of GUI frameworks on other platforms (especially Windows), non-macOS users are usually more tolerant of apps not sharing the same look and feel. - **Worse security**: Compared to the average website running on your web browser, Electron apps are incredibly more powerful (and dangerous) thanks to the NodeJS integration. If not properly configured, web pages running inside Electron can gain access to the entire system, which is particularly dangerous when displaying third-party websites. Luckily, it doesn’t have to be that way, as Electron provides Context Isolation to shield the renderer from NodeJS APIs. Moreover, some believe that the NPM ecosystem is less secure than other counterparts. … In such cases, choosing the native frameworks will most likely be the best choice. That said, if you need to go cross-platform and your application is sufficiently complex, then Electron is really not bad at all compared to the alternatives, especially when done right. Of course, there are some very bloated Electron apps out there and I don’t like them either, but that’s mostly due to careless developers, not Electron.

Electron is a cross-platform framework which allows to develop Desktop applications. They are “native” in a sense that you will build and package the installer for your users, but the integration with OS is limited to what the framework provides, and making custom integrations is not trivial, because the application logic is written in JavaScript and executed by Node.js, so if you want to access OS capabilities, you’ll need to write a Node addon. We’ll talk about that later, but it is not the most straightforward thing, although it can definitely be done. … Shipping the browser also means that we ship its security model. Back in the day, a single JS crash would kill all browser tabs, but today each tab crashes independently. In Electron, this means that every window is its own process and there is no easy way to share data between each window. There is IPC helper implementation, and if each of your windows is on the same domain, you can use broadcastChannel API, but that is inter-process communication with its own set of downsides like non-shared memory and no way to pass any non-standard data. Another thing to keep in mind is that Electron is normally a pre-compiled binary, and that is what the final binary application is unless you compile the source code by yourself. This means that it if you need to handle some OS-level events (e.g. extend AppDelegate on macOS), you might need to re-compile Electron with your native code statically linked. … At this point, you might ask: “well, why would I actually use Electron?”. The main reason to use Electron is that despite all the drawbacks, it is a truly cross-platform framework which minimizes differences between platforms. For example, Tauri (at least at the time of writing, July 2025) relied on the system WebView (essentially Microsoft Edge on Windows and Safari on macOS) and uses Rust to compile the app code to machine instructions, which allows the binaries to be very compact, like ~10-20MB vs ~50-90MB with Electron. However, the system WebView can be very different on Windows 8 vs on some Linux distro vs very old macOS version. This is especially bad on Linux (see this GH Issue), but debugging issues specific to old OS versions is not fun on Windows and macOS as well. Interesting that Tauri is exploring including the frontend runtime with the binaries (ref) to help with this exact issue, but it will definitely increase the size.