HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
openjdk
jdk
Java2019–2026
openjdk / jdk

jdk

JDK main-line development https://openjdk.org/projects/jdk

93Distinct people
129Mentions
0Explicit recommenders
23.5KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

JDK main-line development https://openjdk.org/projects/jdk

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 8:03:49 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year129 dated mentions

Observed mentions: 2019-04-25 22:04:17 UTC to 2026-10-25 02:47:45 UTC.

01020302019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 17 mentions; 1 submissions, 16 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 17 mentions; 0 submissions, 17 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 28 mentions; 5 submissions, 23 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 22 mentions; 4 submissions, 18 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 12 mentions; 2 submissions, 10 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 20 mentions; 5 submissions, 15 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC707
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC606
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC17116
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC17017
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC28523
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC22418
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC12210
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC20515

What Hacker News says

17 sources
Revenge of the Titans is using the java.util.prefs.Preferences class from the Java standard library. Looking at the implementation here: https://github.com/openjdk/jdk/blob/4f607f2adac3798c16a62e90... If the requested directory name has certain "inappropriate" characters in it, it'll encode it using Base64.byteArrayToAltBase64, which is a non-standard base64 encoding using the alphabet defined here: https://github.com/openjdk/jdk/blob/4f607f2adac3798c16a62e90... If we decode the directory name using that alphabet: https://gchq.github.io/CyberChef/#recipe=From_Base64('!%22%2... You can see that it was encoding the text: slots_1.80 Nothing to see here, other than some sloppy filename handling in Déjà Dup.
In Ask HN: Is this weird folder name indication of attempted log4shell attack?
I think you're making my point for me, no? Your arguments are all variants on "I don't understand modern Java and prefer to keep writing buffer overflows than finding out". To answer your questions: 1. Java is these days like UNIX, there are lots of "distros". OpenJDK is the upstream on which most of them are based. You can just use that unless you have some particular preference for the other vendors. However the compatibility situation is much better, there aren't any compatibility issues and JVMs are all more or less drop-in replacements for each other (Android is an exception but has got a lot better over time). 2. You don't need to install Java alongside your app. The JVMs is just a library and a few data files. You can easily bundle it with your app and the user will never know. 3. JCA/JSSE is built in to Java so there's nothing to
Read the rest
build. Additionally you don't have to build Java libraries to use them anyway, because binary distribution works so everyone just distributes binary JAR files. 4. The source code is spread around several modules because JCA is pluggable. But for example a lot of the crypto code is found here: https://github.com/openjdk/jdk/tree/master/src/java.base/sha... 5. Oracle maintains it but other companies contribute, like Amazon, Microsoft, Red Hat etc (well, to Java as a whole). It's released under the GPL with Classpath exception license. They aren't going to come after you for using it - there are 12 million Java developers in the world. The only company that has ever got sued is Google and that's because they violated the (at the time non open source) license of Java to make a mobile version that wasn't from Sun. They knew they were doing it and chose to chance it anyway (which worked out quite well for them actually). Since then Java became fully open source and this no longer applies, and it'd have never applied to normal users of it anyway. I'm not trying to convince you here of anything, only to point out that everyone saying "there was no alternative" is just wrong. The failure mode here is not sufficiently advanced fuzzers. The failure is that there has been an alternative to NSS for years but C++ shops like Mozilla keep maintaining crappy decades old C libraries with memcpy calls all over the place, because they know and like C. That's it. That's all it boils down to.
In This shouldn't have happened: A vulnerability postmortem
It's GPL 2, with an exception which lets you distribute binaries containing your own code linked to the JDK without having to provide the source to your own code (see '"CLASSPATH" EXCEPTION TO THE GPL' at the end): https://github.com/openjdk/jdk/blob/master/LICENSE This is substantially the same as the GCC Runtime Library Exception, which lets you distribute GCC-compiled binaries linked to the GCC runtime without having to provide the source. That's it.
In Revisiting Java in 2021 – Part II
> what is "OpenJDK"? It is an open source project, comprising a codebase, a set of contributors, and various mailing lists, processes, and so on, just like any other open source project. The codebase is a continuation of the original Sun (later Oracle) JDK, now licensed under GPL 2 [1], with a linking exception that makes it fairly similar to the LGPL [2]. The contributors are mostly employees of big companies, with Oracle having by far the largest share. The OpenJDK project releases source code, but does not itself distribute binary builds. In this respect, it is like numerous other open source projects, such as GNU coreutils. Binary builds are made and distributed by operating system distributors (Red Hat, Debian, FreeBSD, etc), and also by various independent groups. As usual, each distributor may or may not add its own patches before
Read the rest
building, and may or may not contribute these upstream. Eclipse Adoptium (formerly known as AdoptOpenJDK) [1] does not apply significant proprietary patches (just branding stuff), so it's a good place to get a plain vanilla OpenJDK build. Amazon's Corretto [4] in principle could contain whatever patches Amazon thinks are cool, but in practice usually just has a few backported bugfixes [5]. Azul's Core (formerly known as Zulu) has a bunch of patches (i couldn't find a list), and an option of commercial support) [6]. Oracle have a couple of builds, but you can ignore them. There are also builds from SAP, Bellsoft, and maybe others, but i have never really looked into them. Most people i know just use the AdoptOpenJDK / Adoptium builds, or whatever their distro gives them. EDIT: I got the Adoptium thing slightly wrong. AdoptOpenJDK made builds; those builds are now called Eclipse Temurin. Eclipse Adoptium is some sort of 'marketplace' where different builds are validated and made available. To me, this sounds like one of those Apache grand ideas that won't go anywhere, but we'll see. [1] https://github.com/openjdk/jdk/blob/master/LICENSE [2] https://opensource.stackexchange.com/questions/1410/what-is-... [3] https://adoptium.net/releases.html [4] https://aws.amazon.com/corretto/ [5] https://docs.aws.amazon.com/corretto/latest/corretto-11-ug/p... [6] https://www.azul.com/products/core/
In Revisiting Java in 2021 – Part II
Naively, max(a, b) would be implemented as return a >= b ? a : b; But if x is -0.0, you're back to the same problem that -0.0 >= +0.0 actually turns out to be true and not false, hence the return value will be -0.0. Looking at the actual implementation[0], doubleToRawLongBits is used again here to take care of this edge case. So it would work, but a lot slower than the version given in the article. 0: https://github.com/openjdk/jdk/blob/36e2ddad4d2ef3ce27475af6...
In One does not simply calculate the absolute value
> In Java it would be a nest of SortComparator interfaces and SortAlgorithm implementors, which would act to hide the algorithm itself. That is odd because when I look at the Java style, DualPivotQuicksort [1], it seems that the language authors did not do that. This is so very strange! Their methods are long, complex, and highly documented. Maybe they must be really incompetent Java programmers? I mean, they did put this obtuse abstraction by hiding it in Arrays. That's super crazy, just look at this monstrosity!!! public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, 0, a.length); } Maybe you need to have an intervention with them? Somehow, in some crazy world, even Java programmers are capable of writing good and efficient code. Its like bad developers might do an awful in job in whatever language they used? C
Read the rest
In Growing object-oriented software vs. what I would do
This is true for Java as well, a `HashSet` is just a `HashMap<T, Object>` where the value is: // Dummy value to associate with an Object in the backing Map private static final Object PRESENT = new Object(); https://github.com/openjdk/jdk/blob/master/src/java.base/sha... A thread-safe implementation is available with `ConcurrentHashMap.newKeySet()`, which uses a similar approach: public static <K> KeySetView<K,Boolean> newKeySet() { return new KeySetView<K,Boolean> (new ConcurrentHashMap<K,Boolean>(), Boolean.TRUE); } https://github.com/openjdk/jdk/blob/master/src/java.base/sha...
In Map[string]interface{} in Go: a user's manual
I came across this post [1] in which the author discovers an undocumented feature in the JVM. "Although the first stable release of Java used bytecode version 45.3, the JVM will actually accept classfiles with versions starting at 45.0. Furthermore, there’s an undocumented feature in the JVM where it parses Code attributes slightly differently when the version is 45.0 - 45.2. In a normal classfile, the stack, locals, and code length fields of the Code attribute have lengths of 2, 2, and 4 bytes respectively, but in a pre-45.3 classfile, the JVM expects them to be 1, 1, and 2 bytes instead. Normally, this means that a pre-45.3 classfile produced by ASM will just crash when run on the JVM because the JVM encounters garbage data while parsing and rejects it. However, if you are very careful, it is possible to construct a classfile that is va
Read the rest
lid when parsed with the 2,2,4 widths, and also valid when parsed with 1,1,2, but parses as different code in each case. This means that it is possible to craft a classfile that executes one piece of code when run on the actual JVM and displays a completely different set of fake code when viewed with reverse engineering tools" TL;DR JVM contained an undocumented feature in the JVM where it parses Code attributes slightly differently when the version is 45.0 - 45.2. The stack, locals, and code length typically has 2,2,4 bytes rspectively; in pre-45.3 classfiles, the JVM expects them to be 1,1,2 bytes instead. [1] https://blog.polybdenum.com/2021/05/05/how-i-hacked-google-a... [2] https://github.com/openjdk/jdk/commit/eedc99c9ab2647f0233e48...
In Java JDK 1.0 (1996)

Showing the 15 most recent of 17 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.