Guava 33.8: What the JRE and Android Flavors Actually Promise
GitHub describes it as Google core libraries for Java. The repository metadata lists Java as its primary language. The metadata lists the Apache-2.0 license. This article stays within the project description and details documented in the GitHub repository README.
At a glance
- What is it?
- Google's core Java library ships two flavors, a stable binary contract, and a set of warnings that matter more than the convenience APIs.
- Who is it for?
- Adopt Guava if you need battle-tested collection types, immutable collections, or a graph library on a Java 8+ JRE or Android API 24+, and you can live with the extra failureaccess dependency. Do not adopt it if you are writing a library that must avoid @Beta APIs without repackaging, if you cannot tolerate serialized form changes, or if you need protection against malicious callers.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Java, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- google/guava51,927 ★ · +12
| Repository | 2026-08-13 | 2026-11-15 |
|---|---|---|
| google/guava | 51.9k | 51.9k |
12 Stars in the last 94 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A Library That Solves the "Missing Pieces" Problem
Guava fills gaps in the Java standard library that most projects eventually hit: multimaps, multisets, immutable collections, and a graph API. The README positions it as a set of core libraries used inside Google and elsewhere. The target user is any Java developer on JDK 8 or higher who is tired of hand-rolling a multimap or defending mutable collections in a shared codebase. It is not a framework or an application server. It is a dependency you add to your build, and the value is in the specific types and utilities you import. If you have never needed a Multimap or an ImmutableList, Guava might be solving a problem you do not have yet. But for a team that maintains a large codebase, the collection types alone justify the dependency.
Two Flavors, One Artifact ID, Two Version Strings
Guava ships as a single Maven artifact, com.google.guava:guava, but the version field selects the flavor: 33.8.0-jre for a Java 8+ runtime, 33.8.0-android for Android. The README shows both in the same XML snippet, which is a convenience and a trap. If you pick the wrong flavor, you may get a class that does not exist or a method that behaves differently. The JRE flavor is the default for server-side work. The Android flavor is for Android apps or libraries that want to remain compatible with Android. The difference is not just a build flag; the android directory contains separate source, and the README notes that unit tests for the Android flavor run on API level 24 (Nougat). That means the Android flavor is tested against a specific API level, so you should match your minSdk to that or verify behaviour on older versions yourself.
Binary Compatibility: The Promise That Shapes Adoption
The README makes a strong guarantee: APIs without @Beta will remain binary-compatible for the indefinite future. The last release to remove non-@Beta APIs was Guava 21.0. This is a rare commitment in the Java ecosystem, and it changes how you plan upgrades. You can bump Guava versions without recompiling every consumer, as long as you avoid @Beta APIs. The flip side is that @Beta APIs are explicitly unstable. They can be modified or removed at any time. The README warns that if your code is a library, you should not use beta APIs unless you repackage them. The Guava Beta Checker exists to enforce this. This is a real constraint: the convenience of using a new @Beta method today can become a migration headache tomorrow. For a library maintainer, the safe path is to run the Beta Checker in CI and refuse to merge code that uses @Beta.
Getting It Running: Exact Coordinates and Gradle Choices
To add Guava, you copy the dependency block from the README. Maven uses groupId com.google.guava and artifactId guava, with version 33.8.0-jre or 33.8.0-android. Gradle users have a choice between implementation and api. The README explains that api is for when you expose Guava types in your public API, and implementation is for internal use only. This matters because if you use implementation but your public methods return an ImmutableList, consumers will get a compile error due to missing Guava on their compile classpath. The README points to Gradle documentation for the separation. There is also a snapshot version, 999.0.0-HEAD-jre-SNAPSHOT, if you want to test the latest master. The README mentions a runtime dependency on com.google.guava:failureaccess:1.0.3, so your build will pull that transitively. You do not need to add it manually, but you should be aware it is there.
The Warnings That Are Easy to Skip
The README lists six important warnings. The serialized forms of all objects are subject to change unless noted otherwise. That means you cannot persist a Guava collection to disk and expect a future version to read it. The classes are not designed to protect against a malicious caller, so you should not use them for communication between trusted and untrusted code. This is a security boundary that Guava explicitly does not provide. For the JRE flavor, the README notes that features in com.google.common.io may not work correctly in non-Linux environments. The mainline flavor is tested on Linux and Windows, so if you deploy elsewhere, such as macOS, test the I/O utilities yourself. The Android flavor is tested on API level 24, so if you support older Android versions, you are outside the tested range. These warnings are not marketing copy; they are the boundaries of the library's guarantees.
A Real Alternative: The Java Standard Library and Its Limits
The obvious alternative is to use the Java standard library plus your own helper classes. Java 8+ gives you streams, Optional, and Collections.unmodifiableList, but it does not give you a Multimap, a Multiset, or a graph API. You could build those yourself, but that means writing and testing code that Guava already provides. Another alternative is Eclipse Collections, which offers similar collection types. The difference is not just feature coverage: Guava's binary compatibility promise is a strong reason to choose it over a library that may change its API more freely. If you only need immutable collections and you are on Java 9+, you could use List.of and Set.of, but those do not cover the full range of Guava's utilities. The choice comes down to whether you want a single dependency with a long-term compatibility guarantee or a more minimal set of hand-rolled utilities.
Maintenance and Upgrade Cost: What You Pay Beyond the Dependency
Guava is actively maintained, with releases v33.7.1 on 2026-08-18, v33.7.2 on 2026-09-29, and v33.8.0 on 2026-11-02. That cadence means you should plan to update regularly to get bug fixes and new features. The cost is not just the version bump; you need to check the snapshot API diffs to see what changed. The README provides a link to snapshot API diffs, which is a concrete way to review changes before upgrading. The binary compatibility guarantee reduces the risk of breaking changes, but it does not eliminate the need to test. The @Beta APIs are the main source of churn, so if you use them, you must track deprecations and removals. The runtime dependency on failureaccess is a small addition, but it is another artifact to keep in sync. The license is Apache-2.0, which is permissive and does not impose copyleft obligations, so you can use it in commercial projects without releasing your source code. That is a low legal barrier, but you should still verify that your use of the library does not conflict with your own licensing policies.
The Verdict: Who Should Adopt, Who Should Not, and What to Verify First
Adopt Guava if you are building a server-side Java application on JDK 8+ and you need collection types, immutable collections, or a graph library. The binary compatibility promise makes it a safe long-term dependency. Do not adopt it if you are writing a library that must avoid @Beta APIs without repackaging, or if you need to serialize Guava objects to disk and read them back in a future version. You should also avoid it if you are handling untrusted input and need a security boundary; Guava explicitly does not protect against malicious callers. Before you commit, verify which flavor you need: 33.8.0-jre for JRE, 33.8.0-android for Android. Run the Guava Beta Checker if you ship a library. Check the snapshot API diffs to see if any upcoming change affects your usage. If you are on Android, confirm your minSdk is at least API 24, or test on your actual target versions. The library is not a silver bullet, but for the right project, it is a solid foundation.
Editorial conclusion
Adopt Guava if you need battle-tested collection types, immutable collections, or a graph library on a Java 8+ JRE or Android API 24+, and you can live with the extra failureaccess dependency. Do not adopt it if you are writing a library that must avoid @Beta APIs without repackaging, if you cannot tolerate serialized form changes, or if you need protection against malicious callers. Before committing, verify your build uses the correct flavor (33.8.0-jre vs 33.8.0-android), run the Guava Beta Checker if you ship a library, and check the snapshot API diffs to see if any future change affects your usage.
Frequently asked questions
What are the benefits of eating guava?
That is a question about the fruit. Guava the software project is Google's set of core Java libraries under the Apache 2.0 license, published as com.google.guava:guava in a JRE flavor that requires JDK 1.8 or higher and a separate Android flavor, adding collection types such as multimap and multiset, immutable collections, a graph library, and utilities for concurrency, I/O, hashing, primitives, and strings.
how to use guava leaves
Leaves are a plant question and nothing in this repository addresses it. For the Java library, use is a matter of declaring the dependency, with groupId com.google.guava and artifactId guava, a version suffixed -jre or -android, and either implementation or api in Gradle depending on whether Guava types appear in your public signatures.
how to set up guava lotus crib
A guava lotus is a different product and this repository has nothing to do with it. If you meant the library, its own build instructions cover only the Maven and Gradle dependency declarations, and it links a wiki page on using Guava in your build plus a separate page for the Android flavor.
Why does my stomach hurt after eating guava?
The repository contains no health guidance. The documented limits of the library are different ones: its classes are not designed to protect against a malicious caller and should not carry communication between trusted and untrusted code, and serialized forms of all objects are subject to change unless noted otherwise.
how to use guava paste
Guava paste is a food product and unrelated to this project. The library's equivalents are its text, primitives, hashing, and I/O utilities, with com.google.common.io called out specifically in the platform testing notes as the area that may not work correctly in non-Linux environments.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/google-guava)Star history chart for your README
[](https://hysenlabs.com/projects/google-guava)Was this useful?