Controls in desktop apps are not just "cookie-cutter" (if I understand correctly what you mean by that). They can be subclassed in C / C++ / Delphi etc. code, to add to, or override, the functionality as well as the appearance of the superclass control. (And individual desktop app developers can, did, and still do this. It is not necessary to buy or downloads such custom controls, anyone can write them - like you say for the web.) This was being done way back in Windows (from as early as Windows 3.x ) and probably in Unix too (X-Windows). In fact, X-Windows may be the source, or one of the early examples, of the famous saying "provide mechanism, not policy" , which is related to this topic. (What that saying implies is that policy - which often involved look-and-feel - could be, and was, provided by higher layers, than the lowest layer, Xlib, which provided the mechanism (for X's style of client-server GUI programming.) I've not checked their implementation details, but probably both GNOME and KDE (which both look and behave rather differently from each other, though both are fundamentally Unix desktop environments), are built on top of X-Windows (in its newer avatar of XFree86 or whatever it is called these days).
 I just did this Google search for the term "paul dilascia windows programming book", and the first search result is:
which is a book by him called "Windows ++: Writing Reusable Windows Code in C++ (The Andrew Schulman Programming Series)" - which was considered an influential book at the time (see Wikipedia page link below). I had read it, years ago, out of interest, even though I was not doing much GUI programming at the time. It showed (with code) how to use C++ to wrap the procedural (WndProc), event-driven Win 32 GUI API in C++ classes, not only for more reusable code (as the book title says), but also how to subclass existing Windows controls and add more functionality to them, or change their appearance, etc. In fact, IIRC, his Windows++ framework completely hid (from the developer) the traditional, error-prone, manually coded WndProc window procedure style of programming, that was the staple of raw Win32 GUI programming. I was quite junior as a programmer at the time when I read the book, but remember thinking even then, that it was something significant that he was writing about, and the book helped me to understand some of those deeper topics to some extent. To describe it another way, the book basically contained the full C++ code for something like a smaller version of MS's MFC or Borland's Delphi or other OO Windows GUI frameworks that wrapped the lower-level raw Win32 GUI API, which involved writing a lot of low-level procedural boilerplate code (with a hand-coded event loop for each app you wrote). That was some general background and history, but more relevant to your point, it shows that customizing controls is very much possible and done in desktop apps too (not just in web apps). And you do not need to write your own GUI framework in order to customize controls, either. You can just take classes from an existing GUI framework that you use, and subclass those classes, and add or override functionality, including both look-and-feel and behavior. The second search result is Paul Dilascia's Wikipedia page - https://en.wikipedia.org/wiki/Paul_Dilascia .
Get dozens of book recommendations delivered straight to your inbox every Thursday.