Remember waaay back in the day that you would go to a store and buy a shrink-wrapped carton box, inside of which were 3 things: A CD or two with the actual application. A manual. A warranty / support card you would fill in and toss in a mailbox. It would entitle you to something like 30 days of free support by phoning them. Whilst it wasn't really in the box, you actually bought a fourth thing: That elusive "merchantability" - in most jurisdictions if you pay for a product, you get certain rights that you can't trivially shrink-wrap-sign-away. That the product is even remotely capable of doing what it is advertised as being capable of doing, for example. If you walk into a shop that looks like a bakery and is called 'bakery', and I order "One sandwich please!", and you hand me a rubber sandwich, I can sue you (don't get excited; just for the value of product, not emotional damages or some such) because you didn't deliver on the implicit contract being formed here. Open Source licenses explicitly disavow this one (read any FOSS license, the term will be in there), based on the (to me, anyway, IANAL) solid idea that you aren't paying. When you think about those 4 things, it turns out that it doesn't actually matter who wrote the software that is on those CDs. It is perfectly fine if, say, Yoyodyne incorporated sells one of these boxes (and wrote that manual, and mans those phone lines, and are the party you would sue if the product wildly / neglectfully isn't fit for the clearly communicated purpose), and Intracorp Ltd also sells a box (with their manual, their phone number, etc), and it turns out the actual bytes on those CDs are identical. So what? That's no problem, right? That is EXACTLY how to think about OpenJDK releases! Let's call that a 'packaging': The bytes of the actual software app on that CD are all the same, but, that manual, the phone lines, an arrangement to keep it security-wise up to date in some fashion, the installer, the website, you name it - that's where every 'packaging' can differ. Oracle JDK, Oracle OpenJDK (Those are different things), Azul JDK, Temurin, Coretto - these are all packagings of the exact same thing: The OpenJDK source repo. It's all from the same git branch, it's just - different folks going through the motions to produce binaries, provide websites where you can download them, take care of distributing security updates (which might be as simple as: Hey, downloader? It's all on you mate, you figure it out - but that's still "an arrangement" and notably, one with some legal exposure). It works this way because Oracle does not want the responsibility. They had that responsibility with jusched.exe and the like (where oracle and the end user are jointly responsible for keeping that JVM up to date, which often failed and java was often the butt of security incidents), and oracle no longer wants to have anything to do with it. So, we have: Oracle JVM. A commercial offering (you pay for it). It has support schedules for each version, where LTS versions have much, much longer support. A 'dev' version of this offering is donwloadable but it explicitly disavows absolutely everything, costs nothing, and the license expires the day the next JVM release is out, even for LTS versions. You should not use these, for obvious legal reasons: It's not meant for that, you aren't licensed to use it as general JVM. Oracle OpenJDK. A FOSS offering published directly by the OpenJDK team. These are supported until the next JVM release, and then support ends immediately - there is no such thing as an OpenJDK LTS release at alL! - you should not actually use these because Oracle clearly doesn't want the burden, and, you get no LTS versions here. Temurin. An open source offering that you do want: They support (Weeellll, remember that whole merchantability thing? You don't pay and it's FOSS. They aim to support; you have no legal standing if they don't, of course) their releases and do engage in LTS: Versions that Oracle JVM terms 'LTS' (technically the only canonical meaning of the term 'LTS release' - oracle's commercial offering) are also termed LTS by the adoptium project. corretto - a FOSS-ish offering paid for by amazon. Free, and the JDKs are specifically tested extensively on Amazon's IAAS (Amazon Web Services) offering. Fine to use, especially if you end up running your java code on EC2 or AWS lambda. Azul, SAP, and many other packagings - I think some parties have a free offering but don't use these unless you have an extensive business relationship with these companies. They are consultancies. If you aren't paying they don't give a shit about you: These products are slippery slopes to capture you as a customer. If you know what you are doing and are aware of why these things exist, by all means. If you're already paying these companies, by all means. I've also said that the usual community default (OpenJDK project's own releases) are a bad default - adoptium is better. Same stuff (FOSS, no guarantees not even merchantability), except with a better track record, a much improved support schedule (namely, LTS releases are actually supported for longer), no clear financial incentive to make a bad project (as oracle would prefer you use the commercial Oracle JDK packaging), and motivation for the product itself (vs OpenJDK whose primary job is to make that source code shine, not to make the packaging of it any good). I guess OpenJDK team itself figured this out too. That's nice.