Yeah, weird-shaped windows are definitely not something that should make a comeback. Just because you could doesn't mean you should.

> Today, all Windows desktop apps look the same as they are the same; they are all built on crap React, Electron, electronbun, and Tauri browser wrappers that mimic the real Desktop apps.

Desktop apps should look the same because they should use the OS GUI framework; that has nothing to do with React and Electron. I can't quite understand this argument; being webview based enables applications to look different from each other, like websites do, not similar. If they still do look similar, that's a good thing.

> The point was usually not usability. It was identity.

Yeah. And usability is sort of a big deal. Applications that implement their own widgets or color schemes or nonstandard shapes usually pay zero attention to usability or accessibility. They almost invariably lack all standard affordances and disregard the standard UX guidelines.

Also, ironically the applications with the most "identity" today tend to be control panels and other accessories by HW manufacturers bundled with device drivers, and they also happen to be the crappiest, most terrible bloatware that an average user is likely to encounter.

I'm all for Win32, but those odd-shapes and custom skins were the precursors and the normalizing precedent for the current default mentality of "visual identity = branding" that's been killing desktop computing experience for years and is one of the reasons we have to endure reacts, electrons and multitude of half-baked widget libraries that consist of things looking like no particular control but all feature blurry text rendering, flaky accessibility, negative information density and their own special sets of bugs.

Unless you're building a Blender or an Ardour or, I don't know, a trading platform or a game, an individualized GUI should be the last of your priorities.

> The point was usually not usability. It was identity.

And we're not even getting usability out of it! Each of those bland react-angles is subtly inconsistent with the OS, with each other, and very often, itself. And in 6 months everything will move around again, for no reason other than to keep the responsible managers employed, without improving UX. And a11y is crying in a corner somewhere, forgotten.

I think those observations get to the crux of the issue:

> That is why weird shaped windows are easy to prototype and expensive to polish.

> But there is an issue with Win32 API programming. And the truth is that custom windows mean doing everything yourself, controlling every Windows message, and that is fragile

Software used to be made by small teams (often of 1). Once released it could be expected to be stable for years.

The priorities have shifted to software that can be built and iterated on quickly, by large teams with high turnover. It’s not uncommon for popular software to get updated weekly, daily.

I suspect this is also why skeuomorphic design lost the evolutionary race - everything needs to be tweaked and aligned and optimized ad hoc. If you want to reorganize the interface, it means potentially recreating a lot of assets. Flat design is interchangeable and modular.

These trends will only get stronger with agentic software engineering - the incentives reward scale and speed.

This is also why we don’t really see large ornate hand carved wooden funiture anymore, it’s all flatpack particleboard now.

I think HiDPI is another reason - these were from the "96 DPI" era where pixels looked the same on every screen. You can draw all your pixel art at 2x (or 3x) and scale it down at load time, but it's not super easy. Also, some of the RAM usage of modern apps is the need for a full backing store for each window - in the "true" win32 days like Windows 95, XP, or Win7 in classic mode, you'd be drawing directly to the front buffer, with no extra RAM/VRAM usage per pixel. Of course it flickered and looked bad, but it was fast and cheap.

> The point was usually not usability. It was identity.

Is it bad that when I read that I immediately thought "this was written by an LLM."

> A freaking notepad app takes almost 50mb in memory when equivalent NOTEPAD done in pure Win32 C takes 1.8mb of memory.

1.8MB? I don't know how much it took on our 386 computer with 4MB RAM and windows 3.11, but hopefully not that much

I worked on Windows apps for many years. The problem is that the Win32 interface only really gets you 90% control. The hardest thing I've ever done was when our product manager decided that color theming our app was an essential new feature. That's when you find out that certain Windows features like scroll bars under certain conditions bypass the usual message loop completely, because they know they can get away with it. The part I remember most vividly was recreating the lowly MessageBox from scratch, because none of the internals of the system supplied one were exposed in a way that you could modify them.

I am reminded of how the CD burning app Disco for Mac would actually smoke while your disc was burning. Standard looking Window but with semitransparent smoke billowing out the top. If I recall, Steve Jobs showed it off on stage and loved it.

I remember in the late 1990s Windows applications, particularly the little weird ones like the app you would use to work a (flatbed) scanner, often tried hard to have unique themed appearances. The industry seemed to lose interest by 2005 or so. I got a job as a Silverlight programmer not long after that which got me to learn WPF and WPF had facilities for theming that seemed capable and well thought out (would be easy, for instance, to turn pill buttons diagonal) but these hardly ever got used, I think the industry had moved on.

Lately I have had to run Office '98 which tries to take over your desktop with Clippy and other things and it still tries to do it to Windows 11. The borderless windows from Office '98 don't quite look right now but it all works.

To my delight, The article also mentioned desktop mascots! I saw a cool video recently where someone made a desktop pet in Godot, and it seems to be cross platform as well.

It seems to be a little fiddly, but not quite win32 level fiddly :) So, maybe a more approachable option for the desktop pet enthusiast.

https://youtu.be/x8BO9C6YtlE

> freaking memory is 77% full when freaking Windows 11 starts up.

Unused memory is wasted memory. 77% is basically caches + private process memory + shared memory. Unless you are comparing by the private committed working set, you usually have no idea of the actual usage. .Net apps and browsers often allocate overcommitted memory to avoid making system calls.

I get it, using browsers for ToDo apps is slow, however measuring their impact is harder than you think. At the same time the best x-platform UI framework is the browser. Qt comes next but it lacks man-decade amount of fixes/polishing to match native font support and text rendering, media handling, accessibility support, hw acceleration and memory pressure behaviors of Skia and Chromium.

From what I understand, there's now a substantial stack of Windows app frameworks from Win32 to MFC and then 4-6 others that came after. There was a good post covering this last month: https://www.jsnover.com/blog/2026/03/13/microsoft-hasnt-had-...

The addition of frameworks like Qt and yes, web wrappers certainly complicates things unless you're presumably deep in it.

What isn't clear to me is whether Win32 is still technically a viable choice for "modern" Windows 10/11 development. In other words, could you submit a Win32 app to the Microsoft Store, if that was something you felt like doing?

> Desktop UI culture shifted from “look at this crazy skin” to “work reliably and get out of my way.”

I miss the wobbly windows I had in Linux when we started playing with Compiz.

Or neko on my Sun machines.

As for weird-shaped windows, I think it is about ergonomics. A different shape requires more thinking to operate. Form should follow function, not the other way around - if the odd shape serves a purpose, then it makes sense. If it's just to show off, or to make the app look different, then it becomes a usability issue.

I used to write a lot of native Windows corporate software in the 90's and 2000's and my standard login window was a floating draggable oval. Nothing else was oddly shaped but I did get a lot of comments on the oval login windows. It was a bit about being unique, marking my "style", and just because I could. I will add though in the 90's it did make me nuts when entire applications were wildly shaped and you had to figure out how to use them.

Editing this to add: I really miss that level of coding and working with Win32. I get that the world has moved on and HTML or some runtime flavour of it has taken over but I too lament the los of true control I once had. I hate that my stack can be broken because some runtime was updated out of my control or the crazy load times of simple projects. I know many today would say it was messy and problematic (and it could be) but it's definitely a lost art form.

Article only mentions manually building an irregularly shaped region from an image

> Every horizontal run of non-transparent pixels becomes a tiny rectangle region, and those runs are combined into one final window region

but there's an easier way: you just use a LWA_COLORKEY with SetLayeredWindowAttributes to make a color transparent, like a green screen. I recall building my own desktop mascot that way. Doesn't work with arbitrary image/content of course since the color can't appear in the content region.

Sonique media player, Trillian messenger and NeoPlanet web browser. I was there, man. Before flat UI and sensible color schemes took hold. For a moment, it was pretty wild.

https://en.wikipedia.org/wiki/Trillian_(software)

https://en.wikipedia.org/wiki/NeoPlanet

https://en.wikipedia.org/wiki/Sonique_(media_player)

Here's the thing, you absolutely can do this in exactly the same way: Make the background transparent and draw within the bounds. You can argue about whether or not you should, but that is the argument. There's no technical limitation.

https://www.electronjs.org/docs/latest/tutorial/custom-windo...

No need to mess with Win32, Godot supports it: https://docs.godotengine.org/en/stable/classes/class_window....

There’s a resurgence of transparent apps and games just because of that.

Minor trivia: the original motivation for adding SetWindowRgn was for Microsoft Bob characters and speech bubbles.

Talking about choice. The article is presented in non-avoidable dark mode. Enough already! Say it with me: dark mode does not directly reduces the brightness, which should be your main concern, it only masks the brightness, which is BAD!

I believe I went to high school with the author, so this took me down memory lane. I wrote an FTP client back in 1999 using only the Win32 API and C. Good times.

> Win32 does not revolve around an update loop you own

    while (GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

...How much more could you own it, really? Is that the LLM talking?

Besides custom outter shapes, you can as well have holes in your windows.

The weird windows were a fun fad for sure, but thankfully, a fad. Winamp was probably the best example of a program with an OS agnostic UI that didn't seem too out of place. It stood out for sure.

It reminds me a bit of one of the reasons Buckminster Fuller's geodesic domes didn't catch on. It's difficult to make rectangular furniture work efficiently in a non-rectangular space. Likewise, it's difficult to efficiently use a non-rectangular window on a rectangular monitor.

I agree on the memory usage of electron apps though. Been using Slack for 10 years now and it has never been slower. A freshly started Slack app on my macOS takes up nearly 1GB. It's nuts imho.

This article brings some flashback from Winamp skinning days.

Anyone else liked to skin they Winamp?

I wish Skeuomorphism returned. I like that these apps were cool and distinct. They were also running in way less memory than electron apps.

This is bringing back some horrible memories. When product wants your app to have a slide-out that looks like a paper scroll...

>A freaking notepad app takes almost 50mb in memory when equivalent NOTEPAD done in pure Win32 C takes [only] 1.8mb of memory.

Kids these days! A full 1.8MB of memory for little more than a wrapper around an existing win32 multi-line text box control!

(Note that I added the "[only]" in the quote above to make it clear what the author meant since the quote was ripped from context).

This reminds me of the mid to late 90's warez scene, all of the key crackers had neat interfaces like this.

So no one here has used winamp or seen an intro screen to a video game? Are you all chatgpt?

Some AI slop aside, nice article to help us remember that the platform is much more powerful if we dare to do some things without the crippling framework help.

Personally, I find that any Windows application that is remotely polished will have its own win32 WindowProc anyway, even if written in higher-level tech.

For example, if you want custom window controls, you need to use a WindowProc + WM_NCHITTEST to tell windows where the buttons are, so the OS can do things like display the window snapping controls when you hover over the "Maximize" button.

Sidenote: as a designer, its disappointing how many Windows apps are subtly broken in a bunch of these ways. Its not that hard. "Modern" UI frameworks generally don't do this work for you either, there's a real lack of attention to detail.

This starts out as a rant, wouldn't know how it ends.

It's good weird-shaped windows disappeared. They are a usability nightmare and override what theme that the users wants for himself.

First, taking the opportunity this discussion presents, I'd like to state for the record, AGAIN, that I have long appreciated the Win32 API and still do -- not because it's great in and out of itself necessarily, it certainly has more warts than your average toad native to the Amazon, but because it de-facto worked for a long while through simple iteration (which grew warts too though) _and_ while it didn't demand Microsoft had everything for _everyone_, it kept Win32 development stable "at the bottom", as the "assembly" layer of Windows development, which everything else was free to build on, _in peace_. Ironically -- looking at the volume of APIs and SDKs Microsoft is churning out today, by comparison, through sheer mass and velocity -- they've proven utterly unable to be sole guardians of their own operating system. There's a plethora of articles shared on Hacker News on this inadequacy on their part to converge on some subset of software that a Windows developer can use to just start with a window or two of their own, on the screen. Win32 _gave you exactly that_. And even `CreateWindow2` export would have worked beyond what `CreateWindow` or `CreateWindowEx` couldn't provide, because you could count on someone who loved it more to just abstract it with a _thin_ layer like WxWidgets etc. Things _worked_. Now there's internal strife between the .NET and "C++ or bust" teams at Microsoft, and the downstream developers are just everything between confused and irritated, this is entirely self-inflicted, Microsoft. It's also a sign of bloat -- if the company could split these groups into subsidiaries, they could compete on actual value delivered, but under the Microsoft umbrella, the result is entirely different.

Second -- and this is a different point entirely -- not two weeks ago there was at least _two_ articles shared here which I read with a mix of mild amusement and sober agreement, about the _opposite_ of what the author of the article linked above, advocates for -- _idiomatic_ design (usually one that's internally consistent):

* https://news.ycombinator.com/item?id=47738827 ("Bring back Idiomatic Design")

* https://news.ycombinator.com/item?id=47547009 ("Make macOS consistently bad unironically")

What I am getting at is that this is clearly different people vocally preferring different -- _opposite_ -- UX experiences. From my brief stint with graphic design, I know there's no silver bullet there either -- consistency is on some level in a locked-horns conflict with creativity (which in part suggests _defiance_), but it's just funny that we now have examples of both, with the above, to which I should add:

> This is why we can't have nice things!

Also, while we "peasants" argue about which way good design should lean -- someone likes their WinAmp-like alpha-blended non-uniform windows and someone else maintains anything that's not defined by the OS is sheer heresy -- the market for one or the other is kept well fueled and another round on the carousel we all go (money happily changing hands).

For my part I wish we'd settle, as much as settling can be done. The APIs should support both, but the user should get to decide, not the developer. Which is incidentally what CSS was _ideally_ kind of was supposed to give us, but we're not really there with that, and I am digressing.

I remember some of the malarkey done with the X11 SHAPE extension. There was a program called xmascot. You could give it an xpm of a character or use one of the presets—typically a cute animal of some sort or a chibi anime waifu. It would show a dangling figurine of this character right on your desktop, autogenerating a few frames of rotation so it could swing from side to side.

Of course X11 is four olds, and there's probably some security justification for not having nonrectangular windows in Wayland, and/or "that's a compositor implementation detail and outside the scope of the Wayland protocol".

is it possible to do this in linux?

Weird window shapes were really great when you were seated at a desktop computer. Not so great on laptops. Not viable on tablets or phones.