I feel like Delphi, along with maybe VB6 and WinForms, have been the pinnacle of easy UI development, and things have gone significantly downhill since then. Especially on the web side, where even a single view sometimes requires having multiple unrelated dependencies (packers, builders, transpilers, etc.), often implicitly-configured to produce output, in head-space. And due to this dependency hell, when porting a project like this to a new platform, or just getting it to run, a slight change in the environment silently breaks the build.

Agree, Delphi was extremely nice way to do UI development.. I've made many small GUIs for everyday tasks back when I was using it.

Unfortunately "dependency hell" was very real -- it was super-easy to download ActiveX controls, install on the system, and then depend on them in the apps. Worse, Windows had a single ActiveX database per computer, and an control installed by a completely unrelated app would appear in the Delphi's palette, ready to be placed on a form. After having a few apps that would not work on friends' computers, I've mostly gave up on ActiveX components completely.. luckily third-party Delphi components were better - at least the compiled binaries would work. Source code still required system-wide install though...

If you think that "pip install", or "npm install", or even "apt-get install" on a Linux system is bad, you haven't seen what Delphi world was like. But to be fair, it's not really Delphi's fault - all Windows development was like that, full of bespoke settings that need to be set on each PC. For a complex software, it was normal to spend a few days just setting up the system so you can do initial build.

Another Delphi-specific issue was that by default forms were specified in pixels, and were hard-coded to specific font sizes; and color pickers had hardcoded colors (as opposed to system theme colors) prominently displayed. Unless you were very careful, it was very easy to make an app that could not handle different font or screen theme. And many apps that would benefit greatly from being resizable were non-resizeable instead, just because it was easier.

FWIW ActiveX specifically was really more so that Delphi is able to use the Visual Basic stuff than something native to Delphi. Components made for Delphi specifically are (usually) compiled as part of the final executable without needing ActiveX.

In fact AFAIK ActiveX support in Delphi was implemented by generating a wrapper component that converted the ActiveX control stuff to what Delphi "naturally" speaks.

For forms, even in Delphi 2 you can use the "align" property in several controls to automatically position them inside a container using the top, bottom, left, right and client area. The areas also stack so you can, e.g., position several controls at the top area and you'd get an effect similar to what a VBox container would provide in other toolkits. Though the initial versions of Delphi did not have this available everywhere, it was added to various controls over time.

Later versions also added "anchors" so that you can drag-drop stuff visually to the form but also have them resize automatically based on the parent's size. Lazarus (sort of open source Delphi-like IDE) extended this to allow anchoring stuff related to other control (so, e.g., you could have a button's right side a few pixels from another button's left side and that button's right side be a few pixels from the container's right side, or have a label be placed at the middle of an input box, or other stuff like that).

> And many apps that would benefit greatly from being resizable were non-resizeable instead, just because it was easier.

Maybe, but Delphi had anchor fields that you could use to make everything resize nicely.

The problem with that time period was that most applications were designed to not be resizeable, including most of the ones that came with Windows itself.

We still have that - some of the Windows programs right now can't be resized (Thinking specifically of dialogs and windows for device manager->driver details, or explorer->options).

This wasn't a Delphi problem at all; it was a Windows problem because that was the convention on Windows at the time.[1]

[1] EDIT: s/Windows/GUI systems/g

> This wasn't a Delphi problem at all; it was a Windows problem because that was the convention on Windows at the time.

And I don't think other GUI systems were all that much better. Eg MacOS has plenty of fixed size stuff right now.

Yeah; my comment specifically called out Windows, but to be fair, all the GUI systems at the time had the same restrictions.

It was convention across all GUI systems.

No... Motif/CDE had resizable/constraint layout in early 90's

And these programs, compiled in the ninetees, still run today on modern Windows with a functional UI. Microsoft, Borland and others then built developer tools and platforms to last. I think that cross-platform (including web) and touch changed the game because it wasn’t a simple and controlled ecosystem anymore. All of Microsoft’s successors to Win32 seem to be replaced sooner or later by something else, even in the Windows ecosystem, with Win32 still being supported. Let alone the web frameworks.

I also feel like this created a kind of positivity at the time rarely experienced today. I remember these Delphi conferences I used to go to as a teenager with my dad with many of the names Marco mentioned in his acknowledgments present, including himself. It was really rapid application development (RAD) without many of the stuff that parent mentions that brings so much struggle today (frontend) software development. People were having fun building software.

I’m happy to see that most of these names still seem to be able to make a living off Delphi. There’s probably still a lot of critical Windows enterprise software being maintained that needs consulting and support. Including my dad’s software he wrote 30 years ago which is still being maintained and used daily.

> There’s probably still a lot of critical Windows enterprise software being maintained that needs consulting and support.

At my old company, it took 2 years and $2 million to re-write an application in Java. That's the cheapest project that Accenture would take.

So as long as you keep your legacy service contracts under that, you're fine. It might even be $3 million now with the new Java licensing terms.

Delphi and Visual Basic 6 were definitely not the pinnacle of UI development.

For example, all layout was pixel based. Making windows resizable required much complex ad-hoc code, and internationalization was hard as well. Very early in my career, I have spent person months clicking through every single screen in a large desktop application to find words cut off due to words having different lengths (measured in pixel) in different languages. I knew what "Ok" and "Cancel" meant in half a dozen languages. At the time, Java was really breaking ground with container based layouts in Swing. Delphi and Visual Basic caught up only in the .NET era.

Don't know about VB6, but at least Delphi had Align property and TPanel/TGroupBox. Together, it allowed to make apps that handle resizing just fine without any custom logic.

(it has been a very long time, but I think those only handled internal composition and not overall window size.. so you'd still need some custom code if you wanted dialogs as compact as possible. But as long as you never missed setting Align property, you did _not_ have to manually resize every control for different text/font size).

> Delphi and Visual Basic 6 were definitely not the pinnacle of UI development.

> All layout was pixel based.

I'd say that was a very reasonable trade-off at the time, when most screens were somewhere between 640x480 and 1024x768 resolutions at 72 DPI. This simplified UI design sufficiently enough that VB/Delphi provided an optimal solution that, yes in hindsight, would most accurately be described as a "local maxima" for the environment and the time.

> Making windows resizable required much complex ad-hoc code

I remember there were ActiveX controls one could drop onto their form that would attempt to derive the layout based on initial positioning of controls, i.e. that a lower row of buttons should be anchored to the bottom of the window, while textboxes are took up a larger area would automagically resize with the window.

> For example, all layout was pixel based.

These sort of excuses always come up when Delphi and its insane productivity is mentioned. The same thing happens in conversations about how slow software has gotten.

High-DPI displays, internationalization, and accessibility are a pain but don't introduce enough complexity to hand-waive away the criticism.

Going a bit off-topic, but the browser is carrying around so many legacy concepts and ideas - it's a complete disaster - but it's the only option. The document object model is slow and weird to use to build reactive user interfaces.

We should demand something better. The browser is a local maximum as an application platform, and we should stop defending it.

Accessibility too

No it wasn't, this keeps being wrongly repeated.

Both had layout managers, they just required a bit more effort to use, and developers as we know are all lazy.

You can’t look at the language in isolation. Visual Basic was backed by the fantastic Visual Studio for development. That ecosystem was way more mature than Java ever got with Swing et al. IMO, if there’s one thing MS ever did right, it was how they nailed WYSIWYG GUI app development. Now they’re going backwards with the WinUI XAML crap.

> Now ... XAML

Microsoft has been pushing XAML for long enough that it could drink, drive and vote in my country

VB6 was its own thing separate from Visual Studio.

I came from Visual C++/Basic world when I first got my Mac and dove into Xcode for the first time (2002? 2003?). Flexible layouts, connecting UI elements to datasources, localization...

Oh my was I amazed.

"easy UI development" Java never really got that part right.

Yes it did, IDE tooling was the answer, and Netbeans still provides its Matisse, WindowBuilder on Eclipse, and as does InteliJ.

Back in the day, JBuilder offered a Delphi like experience.

What I would agree is that the thing that actually made Swing hard are the defaults, which required books like "Filthy Rich Clients" as gate into making wow Swing applications.

Layout managers were well established industry-wide by the 90s, which is where I started using them.

Absolutely - Qt had already figured out how to do layout before Swing was much of a thing (AWT doesn't count, yuck).

I would love something like Delphi/VB6, but made for web development.

My day job involves working with PeopleTools, which basically does this. Draw forms (and build all of the supporting objects), save them, and they're accessible through a web browser. You don't need to know HTML, CSS, JS, etc (though it can help), and you can knock out a very based CRUD form in no time without writing any code.

I think the Microsoft Power Platform has features similar to this as well.

But neither of these options are very accessible to regular folks. Something that has the ease of development of Delphi, the deployment simplicity that comes with presenting the application via a web browser, and is accessible to regular folks would be incredible.

Xojo Web aims to do exactly what you describe.

https://xojo.com/products/web.php

I haven't really used it - I'm just a hobbyist coder who enjoys the VB6 style development of the desktop version of Xojo.

Wow, a quick cruise through the documentation suggests that this is EXACTLY the kind of thing I'm looking for!

I find myself waffling between "This is too expensive for me to play around with at home" and "Considering what this does, $399 really isn't that bad..."

There is a free trial or a $100 personal use version or some such, at least there was, when I checked it out a while ago.

There was Delphi for PHP

Is https://delphi.fandom.com/wiki/Delphi_for_PHP the one you're thinking of?

This is truly interesting, and the description on that wiki page suggests that it might be exactly what I'm looking for, but it seems like any concrete information about it has vanished.

Its a very old product, and afaik it was discontinued (many) years ago. It was reasonable for crud applications, nowadays you can do rougly the same with any oss airtable clone. Could have been a great tool, but unfortunely poor marketing and lack of vision killed the product.

I was several times required to build simple web apps, and it wasn't hard. I used Python, Flask, Jinja2, Bootstrap, and maybe one or two functions from jQuery for AJAX. It was very easy, and I know only Python and basic HTML and CSS. I don't know any JS/TS because I'm a Computer Vision Engineer.

These web apps show tables with data, images with figures, and some controls to request calculations or data from a server. jQuery is used to update the drop-down list according to previous choices.

Including being high level, low level systems programming, and compiled ahead of time.

It is incredible that given its heritage, we have had to wait 25 years for .NET to finally provide a similar experience, and there are still some rough edges.

While it offered a way to perform AOT compilation, NGEN was only meant for fast startup and nothing else.

> It is incredible that given its heritage, we have had to wait 25 years for .NET to finally provide a similar experience

It's even the same person: Microsoft poached Anders Hejlsberg, creator of both Turbo Pascal and Delphi, to architect .net.

This myth keeps being repeated.

If anyone poached Anders Hejlberg, it was the ex-Borland friends working at Microsoft, under the usual referral program many companies have.

Actual history behind on what happened,

"Anders Hejlsberg: A craftsman of computer language"

https://behindthetech.libsynpro.com/001-anders-hejlsberg-a-c...

And yes that is why .NET not having proper AOT in 2001 was such a disappointment.

I was so in love with Delphi 7 (didn't care much for Delphi 8, didn't try any version after). I don't think I've ever been more excited about a programming language/environment as when I was easily and quickly creating desktop applications with Delphi 7.

It is the result of cheaping out by the entire tech industry. Responsive design to support multiple resolutions and pixel density was extrapolated to use a single framework (HTML+JS+CSS) for every single device that exists. Except for a few, most businesses deploy Web based apps on browsers, desktop apps and mobile phones. Usually from the same monorepo. Add developer laziness and unnecessarily tight deadlines, we end up in the current situation.

One reason for this is when the big players move their business models over to taking your data and renting it back to you, there's no profit motive in pushing state-of-the-art ux when they just give their apps away to act like honeypots. MSFT gives their stuff away if you get on Azure. Atlassian charges 14 bucks a seat if you use their cloud. Lots of people who use this stuff have a laptop plus a bigger monitor their company bought to get their work done and it's like staring into an empty desert every day.

These days, I'd say Flutter is the closest alternative to something like VB6 or Delphi.

While I get the aversion, HTML+CSS is a pretty good combination for layout and there are efforts towards application tooling for other languages. That said, I don't dislike JS/TS nearly as much as some on here. It's a highly expressive language that's flexible enough to get things done in a number of ways. And yeah, the overhead is kind of crazy, especially when devs bring in massive dependency chains. As a whole, it's still one of the better options for getting an application "everywhere".

Yep. I tried to find something similar. I tried Lazarus, Visual C#, Qt Studio. It's all a sad imitation of what we had with VB6 and Delphi.

> Yep. I tried to find something similar. I tried Lazarus, Visual C#, Qt Studio. It's all a sad imitation of what we had with VB6 and Delphi.

What's wrong with Lazarus, compared to Delphi?

I remember a product called PHP builder, that was out for awhile. It was supposed to make it easier to create and deploy PHP apps.

It failed within a year or two.

Is there kinda gui builder for web?

I'm not going to minor the merits of Delphi, but this...

> Especially on the web side, where even a single view sometimes requires having multiple unrelated dependencies (packers, builders, transpilers, etc.),

... is only true if you jumped on the SPA bandwagon. Things don't have to be this complicated.

Isn't Retool (https://retool.com) like modern-day Delphi?

I can't answer, because that website is so incredibly disorienting I had to close it after scrolling for a few seconds

That comment seemed a little bit snide to me, so I visited the website just to prove you wrong. Unfortunately, it was so disorienting I had to close it after scrolling for a few seconds :0

Interface Builder for NeXT stuff let you build a UI and test it quickly

I have barely 2 years of experience in software development, so I wasn't around doing Delphi and stuff (I vagely remember seeing a Pascal book at my grandparent's).

However I feel like the current paradigm of declarative ui, with automatic re-render, like React (and what I actually use: Compose Multiplatform) is very good for producing maintainable applications and encourages UI decoupling.

I agree that the dependency hell and project setup parts on the web are horrible, but I wouldn't say it's part of "UI Development".

> I vagely remember seeing a Pascal book at my grandparent's).

First time someone used “grandparent” and I could relate :-)

My grandfather, on the other hand, was a gold miner in Alaska, then returned to Seattle in the 1920s just in time for the Great Depression. So I’m just a bit older than you ;)

Is this applicable to:

https://www.lazarus-ide.org/

Yep, I'll have a major rich gui workstation client/server package with basic D365 functionality coming out in I hope about 8 months. Win, Linux, hopefully Mac, and browser. The browser version is definitely legacy gui compared to the native versions, just because it's browser.

> Yep, I'll have a major rich gui workstation client/server package with basic D365 functionality coming out in I hope about 8 months.

What's D365?

While not exactly 1:1, the vast majority should be.

The Free Pascal language used by Lazarus is very similar to Delphi's Object Pascal[1], and the Lazarus Component Library[2] is modeled to closely match Delphi's Visual Component Library.

[1]: https://wiki.freepascal.org/Object_Pascal

[2]: https://wiki.freepascal.org/LCL

I’ve used Lazarus a bit and it mostly replicates the APIs and experience of using Delphi in this timeframe

Really cool seeing you here Marco, as a teenager I got into Delphi and a part of that were your books (and some local Delphi forum). So thanks for being part of my 14 year old self spiraling into programming!

Borland was really a pioneer, made great stuff.. Sad they couldn't survive the Microsoft onslaught both in terms of product and tactics.

They made some serious strategical blunders that were entirely unforced, and they did so at a critical time.

They drank every last drop of the enterprise kool-aid, and put Delphi on life support when spinnig it off failed[1], just as Microsoft got some .Net momentum going.

A lot of Delphi developers saw the signs and jumped ship during those years.

[1]: https://en.wikipedia.org/wiki/CodeGear

It was mostly unforced errors. They tried to compete directly with Microsoft by buying word processors, databases, making a spreadsheet, etc. It was pretty clear to me even at the time.

Microsoft, on the other hand, is severely underrated for its ability to just not fuck up too often.

This book was a great help to me years ago, and I still have a hard copy lying around. It's wonderful to now have a digital edition as well. I often look back on my time with the Delphi IDE with fond memories—though, thankfully, the bad ones seem to fade faster.

the blog does not load to me, but is this really "Delphi 5"?

As in Borland Delphi 5 "Argus" released in August 1999 which introduced XML support and ADO databases?

Sorry, the blog has hiccups with large traffic... Yes, this is a book on Delphi 5 I made available for free... but with hundreds of notes indicating what has changed and what is still relevant. A lot of content is applicable to Delphi 12.3, released this month!

Yes: "I've been creating a free to download edition of my classic "Mastering Delphi 5" with footnotes indicating what is different today"

Many thanks Marco for providing this.

Thank you, it was a nice project, partially walking down the memory lane, but also checking how many features in that version of Delphi are still core today -- not just for the product but for the industry

Memory lane, indeed! For me, as well - 25 years ago, I translated the Delphi 4 version of this book to Polish - I'm happy to see that both you and Delphi are still going strong!

Which Delphi version(s) can the book be used with?

I like Delphi and FreePascal and Lazarus and have used all of them a little, now and then, to create some small personal and paid business apps, Delphi in multiple versions with gaps between versions, from 2 onwards until the 'Berlin' version, IIRC.

And yes, thanks, Marco, for making this book available. I had bought a copy of one of your Delphi books around the 3 to 5 version timeframe, cannot remember which version right now.

Also, I had downloaded your Object Pascal Handbook a few years ago, which is a great resource, because we devs need to know our programming language well too, not just the IDE or the libraries, which is what some book authors focus on. Thanks for that too.

Need to set aside some time to do some more Pascal work for fun and profit.

I loved Delphi 1 ages ago but I won't fork thousands of dollars for a language.

> I won't fork thousands of dollars for a language.

Lazarus:

https://www.lazarus-ide.org/

FPC:

https://www.freepascal.org/

Cost: $0.

Agree. Making everything free (including the freedom, e.g. MIT license): SDK, cmdline tools, etc... And only charging for IDE/RAD environment would enormously boost the language popularity.

The same goes for Eiffel.

Delphi 5 was awesome. From memory it was the last version where you could do jump to definitions on tons of the systems/built in code. 6 had that obscured somehow

Delphi was nice, but the community was horrible to me, accelerating the move of my company to C#.

I have exactly opposite experience, Delphi was awful UI, verbose language experience, with hops and tricks and a ton of Win32 rendering to do simple controls like a ComboBox with checkboxes. Yet the community was brilliant, always helpful and SO questions answered the same day!

I’m a bit surprised by that! Can you tell us a little bit more?

Interesting. Is it still runnable on Windows 10/11? I guess it would be still fun to use Delphi for personal projects.

> I guess it would be still fun to use Delphi for personal projects.

Like many of the other commenters here, I use Lazarus for Delphi projects in 2025 (Not just personal projects, but business projects too).

I don't really like the language too much, but:

1. Pascal (or Object Pascal) is very readable compared to almost anything else I've used[1]. I can come back to code from 2 years ago and spend a few minutes to context switch back into the language.

2. The language gotcha's are a small enough pain point that they are outweighed by the advantages of the type creation. I like being able to create a ranged integer type, which is then enforced by the compiler.

3. For most stuff, the majority of my logic is written using opaque types in C and then simply linked into the Lazarus GUI. I originally started using strong isolation and decoupling in C to enforce typing guarantees, but a side-effect of this is that it makes it exceptionally easy for other languages to reuse the program logic.

[1] I've been programming for money since the mid-90s, so you can assume that I've used almost everything that was mainstream (or top 10 in terms of popularity) each year since 1995.

Windows doesn't break backwards compatibility unless it is absolutely worse to keep it around. Think about old SMB protocol that caused security issues. The old Delphi programs continue to work since both the API design is more future-proof and Microsoft did a mind-boggling amount of work to keep ABI stable.

I recall some very nasty hacks and often-won't-work-at-all issues in trying to get Delphi 6 to run on Vista or Windows 7. Windows breaks backwards compatibility more often than "never".

Was it Delphi or the installer? I do not have Delphi 6 but i have Delphi 2 and while the installer doesn't work out of the box (IIRC you can make it work with otvdm which can run 16bit programs on 64bit windows) you can simply just copy the files from the CD and it'll work.

Here is a screenshot from ~5 years ago when i was playing around writing a Quake 1 level editor in Delphi 2 under Windows 10[0] (i switched to using Linux as my main OS soon after and converted it to Lazarus[1]).

[0] https://i.imgur.com/I48gyMv.png

[1] https://i.imgur.com/7MSH98p.png

As I recall, the installer seemed to complete fine, but the IDE itself had problems, and this was consistent on every Vista and W7 computer. Windows XP computers could run it without issue.

It's been a long enough time that the details have left my brain, but the feelings of pain have not been forgotten :-)

Hey this is interesting. Did you write the rendering code in Delphi too?

Did a bit of search, is it QuARK?

Yes the rendering code is in Delphi too. It uses an OpenGL control i wrote some years ago[0] which include OpenGL bindings for Delphi 2 (i haven't tested later versions). The control is actually a conversion of one i made for Borland C++ Builder [1].

It is not QuArK, though AFAIK QuArK was made in Delphi too. There have been a few other Quake editors made in Delphi, like the qED Quake Editor which was one of the earlier Quake editors (the author wrote a book about quake mapping too[2]).

[0] http://runtimeterror.com/tech/dglvp/

[1] http://runtimeterror.com/tech/bcbgl/

[2] https://archive.org/details/unofficial-quake-level-design-ha...

Man I love it. Back in 1999/2000 I was very into Quake mapping and Half-Life mapping. I didn't make any good maps but the community was great. I remember talking to other mappers on ICQ every night.

I believe the community is still thriving.

Thanks, I like your website BTW. It reminds me of the 90s.

I would be surprised if Delphi 5 ran without a hitch on Windows 10/11.

On the other hand, I'd also be surprised if the code couldn't be ported as-is, with just some minor tweaks if any, to the latest Delphi release (released this month).

The transition to Unicode strings was a breaking change that did have some impact, but if the code used string manipulation routines instead of direct byte manipulation it should work without any change.

I rebuild a large number of demos with no change. Well, the UI looks date, you need to manually enable HighDPI (one checkbox away), do a few tweaks. The IDE plugins, those are broken. And some libraries don't ship any more.

That's more or less what I expected. I've recompiled some older D3 stuff in modern Delphi and most just works. The ones that were really troublesome used third-party components.

>> I would be surprised if Delphi 5 ran without a hitch on Windows 10/11

I'd be surprised if it didn't. Not Delphi, but I've been helping a client update their Windows program, from a compiler which shipped in 1998. Their program, with that compiler, runs just fine on Windows 11.

The backward compatibility of the Win32 API is such that I regularly use programs last compiled 20 years or more ago.

It's more hit or miss than you might think. If you're just using mostly basic parts of the Win32 API then it is basically about as solid as any backwards compatibility ever has been.

The fall off occurs as you veer off into deeper holes:

- Multimedia software and games tend to hit on areas of Windows where compatibility is far from perfect.

- Even 32-bit software would sometimes have random Win16 binaries, and those are not emulated; I don't blame Microsoft or anything, but they could support it if they wanted to. (Understandably, they do not.)

- Software that uses truly obsolete Windows components may no longer work. AFAIK .NET Framework 1.1 hasn't been supported since Windows 8. Old ActiveX and COM components can also be a problem.

This has led to some situations where you might actually have better luck running the old software under Wine and Linux than modern Windows, especially for some older games.

It's not that Microsoft didn't do immense amounts of work here, but in practice there are some holes I've run into.

> Even 32-bit software would sometimes have random Win16 binaries

InstallShield being a common one in that regard. So common that 64-bit Windows, which doesn't support 16-bit binaries, contains code to handle specifically[1] InstallShield and Acme 16-bit binaries[2].

[1]: https://devblogs.microsoft.com/oldnewthing/20131031-00/?p=27...

[2]: https://learn.microsoft.com/en-us/windows/win32/winprog64/ap...

Microsoft sure has done a great job, but I have experienced some issues around Program Files and registry virtualization, along with UAC.

I suppose if you run it as admin and/or install it outside Program Files it'll make it a lot less troublesome.

So, not unexpected, but I'd still be mildly surprised.

> some issues around Program Files and registry virtualization, along with UAC.

Now that's rattling a thing in my brain. I recall disabling UAC was one of the more consistent ways to get Delphi 6 to even run on Windows 7, and even then it wasn't a guarantee.

Yeah, I had the displeasure around 2009-2011 of trying to get an old IDE version running on then-current versions of Windows, with multiple Vista and 7 computers in the office. It ran fine on Windows XP, but newer OSes were not so lucky.

Perhaps the solution was to purchase a newer Delphi, but that avenue wasn't sought after.

Yeah... I saw a lot of poorly written apps using localized data in the application's directory, when they started locking down Program Files, all kind of bugs started to pop up. I don't blame MS much, they had some compatibility shims in place, but it was still troublesome. Mostly blame the early app devs for not understanding separation of the application/libraries and the data the app uses/manipulates.

Should. Visual Studio 6 / Visual Basic 6.0 keeps running on Windows 10/11

MS has actively maintained compatibility between the VB6 runtime and Windows.

I'm looking forward to using this as the missing documentation for Lazarus

Congratz Marco!