Need help with thrifty?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

466 Stars 79 Forks Apache License 2.0 540 Commits 16 Opened issues


Thrift for Android that saves you methods

Services available


Need anything else?

Contributors list


Build Status Android Arsenal codecov

Thrifty is an implementation of the Apache Thrift software stack for Android, which uses 1/4 of the method count taken by the Apache Thrift compiler.

Thrift is a widely-used cross-language service-definition software stack, with a nifty interface definition language from which to generate types and RPC implementations. Unfortunately for Android devs, the canonical implementation generates very verbose and method-heavy Java code, in a manner that is not very Proguard-friendly.

Like Square's Wire project for Protocol Buffers, Thrifty does away with getters and setters (and is-setters and set-is-setters) in favor of public final fields. It maintains some core abstractions like Transport and Protocol, but saves on methods by dispensing with Factories and server implementations and only generating code for the protocols you actually need.

Thrifty was born in the Outlook for Android codebase; before Thrifty, generated thrift classes consumed 20,000 methods. After Thrifty, the thrift method count dropped to 5,000.



repositories {

// For snapshot builds maven { url '' } }

dependencies { implementation '' }

On the command line:

java -jar thrifty-compiler.jar --out=path/to/output file_one.thrift file_two.thrift file_n.thrift


./gradlew build


./gradlew check


We welcome contributions at all levels. Contributions could be as simple as bug reports and feature suggestions, typo fixes, additional tests, bugfixes, even new features. If you wish to contribute code, please be sure to read our Contributing Guide.

Differences with Apache Thrift

Thrifty structs and clients are 100% compatible with Apache Thrift services.

The major differences are:

  • Thrifty structs are immutable.
  • Thrifty structs are always valid, once built via a builder.
  • Fields that are neither required nor optional (i.e. "default") are treated as optional; a struct with an unset default field may still be serialized.
  • TupleProtocol and JsonProtocols are unsupported at present.
  • Server-specific features from Apache's implementation are not duplicated in Thrifty.

Guide To Thrifty

Thrift is a language-agnostic remote-procedure-call (RPC) definition toolkit. Services, along with a rich set of structured data, are defined using the Thrift Interface Definition Language (IDL). This IDL is then compiled into one or more target languages (e.g. Java), where it can be used as-is to invoke RPC methods on remote services.

Thrifty is an alternate implementation of Thrift targeted at Android usage. Its benefits over the standard Apache implementation are its greatly reduced method count and its increased type-safety. By generating immutable classes that are validated before construction, consuming code doesn't have to constantly check if required data is set or not.

Interface Definition Language

The Thrift IDL is a simple and standardized way to define data, data structures, and services:

// Let's call this example.thrift

namespace java

struct Query { 1: required string text, 2: optional i64 resultsNewerThan }

struct SearchResult { 1: required string url, 2: required list keywords = [], // A list of keywords related to the result 3: required i64 lastUpdatedMillis // The time at which the result was last checked, in unix millis }

service Google { list search(1: Query query) }

For an authoritative source on Thrift IDL, Thrift: The Missing Guide is an excellent introduction.

Generating Code


to compile IDL into Java classes:
java -jar thrifty-compiler.jar --out=path/to/output example.thrift

The example file will result in the following files being generated:

  - com/foo/bar/

The interesting files here are, of course, our domain objects


The latter looks like this:


import; import; import; import; import; import; import; import; import; import; import; import java.util.ArrayList; import java.util.Collections; import java.util.List;

public final class SearchResult implements Struct { public static final Adapter ADAPTER = new SearchResultAdapter();

@ThriftField( fieldId = 1, isRequired = true ) @NonNull public final String url;


  • A list of keywords related to the result

  • / @ThriftField( fieldId = 2, isRequired = true ) @NonNull public final List keywords;


  • The time at which the result was last checked, in unix millis

  • / @ThriftField( fieldId = 3, isRequired = true ) @NonNull public final Long lastUpdatedMillis;

    private SearchResult(Builder builder) { this.url = builder.url; this.keywords = Collections.unmodifiableList(builder.keywords); this.lastUpdatedMillis = builder.lastUpdatedMillis; }

    @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof SearchResult)) return false; SearchResult that = (SearchResult) other; return (this.url == that.url || this.url.equals(that.url))

    && (this.keywords == that.keywords || this.keywords.equals(that.keywords))
    && (this.lastUpdatedMillis == that.lastUpdatedMillis || this.lastUpdatedMillis.equals(that.lastUpdatedMillis));


    @Override public int hashCode() { int code = 16777619; code ^= this.url.hashCode(); code *= 0x811c9dc5; code ^= this.keywords.hashCode(); code *= 0x811c9dc5; code ^= this.lastUpdatedMillis.hashCode(); code *= 0x811c9dc5; return code; }

    @Override public String toString() { return "SearchResult{url=" + this.url + ", keywords=" + this.keywords + ", lastUpdatedMillis=" + this.lastUpdatedMillis + "}"; }

    @Override public void write(Protocol protocol) { ADAPTER.write(protocol, this); }

    public static final class Builder implements StructBuilder { private String url;


    • A list of keywords related to the result
    • / private List keywords;


    • The time at which the result was last checked, in unix millis
    • / private Long lastUpdatedMillis;

    public Builder() { this.keywords = new ArrayList(); }

    public Builder(SearchResult struct) { this.url = struct.url; this.keywords = struct.keywords; this.lastUpdatedMillis = struct.lastUpdatedMillis; }

    public Builder url(String url) { if (url == null) {

    throw new NullPointerException("Required field 'url' cannot be null");

    } this.url = url; return this; }

    public Builder keywords(List keywords) { if (keywords == null) {

    throw new NullPointerException("Required field 'keywords' cannot be null");

    } this.keywords = keywords; return this; }

    public Builder lastUpdatedMillis(Long lastUpdatedMillis) { if (lastUpdatedMillis == null) {

    throw new NullPointerException("Required field 'lastUpdatedMillis' cannot be null");

    } this.lastUpdatedMillis = lastUpdatedMillis; return this; }

    @Override public SearchResult build() { if (this.url == null) {

    throw new IllegalStateException("Required field 'url' is missing");

    } if (this.keywords == null) {

    throw new IllegalStateException("Required field 'keywords' is missing");

    } if (this.lastUpdatedMillis == null) {

    throw new IllegalStateException("Required field 'lastUpdatedMillis' is missing");

    } return new SearchResult(this); }

    @Override public void reset() { this.url = null; this.keywords = new ArrayList(); this.lastUpdatedMillis = null; } }

    private static final class SearchResultAdapter implements Adapter { // Uninteresting but important serialization code } }

The struct itself is immutable and has a minimal number of methods. It can be constructed only with the assistance of a nested

, which validates that all required fields are set. Finally, an Adapter implementation (whose body is omitted here because it is long and mechanical) that handles reading and writing
structs to and from

Finally and separately, note

- the former is an interface, and the latter is an autogenerated implementation.

You may notice the similarity to protobuf classes generated by Wire - this is intentional! The design principles codified there - immutable data, build-time validation, preferring fields over methods, separating data representation from serialization logic - lead to better, safer code, and more breathing room for Android applications.

Using Generated Code

Given the example above, the code to invoke
might be:
// Transports define how bytes move to and from their destination
SocketTransport transport = new SocketTransport.Builder("", 80).build();

// Protocols define the mapping between structs and bytes Protocol protocol = new BinaryProtocol(transport);

// Generated clients do the plumbing Google client = new GoogleClient(protocol, new AsyncClientBase.Listener() { @Override public void onTransportClosed() {


public void onError(Throwable error) {
    throw new AssertionError(error);


Query query = new Query.Builder() .text("thrift vs protocol buffers") .build();

// RPC clients are asynchronous and callback-based, new ServiceMethodCallback>() { @Override public void onSuccess(List response) { // yay }

public void onError(Throwable error) {
    Log.e("GoogleClient", "Search error: " + error);



Every project has its own requirements, and no one style of boilerplate can fill them all. Thrifty offers a small but powerful plugin model that you can implement, using the standard Java SPI mechanism, which will allow one to customize each generated Java class before it is written out to disk. Read more about it in the thrifty-compiler-plugins README. You can see a worked example in thrifty-example-postprocessor.

Hiding PII with Redaction and Obfuscation

Personally-Identifiable Information (PII) is an inevitability in most systems, and often there are legal consequences if it is not handled carefully. Thrifty allows you to avoid logging PII contained in generated classes by supporting both total redaction and obfuscation. It is as simple as adding annotations to your Thrift IDL:

struct User {
  1: required string email (obfuscated)
  2: required string ssn (redacted)

The difference between redaction and obfuscation is small but important. In

fields are totally replaced with the string
- no information survives. This meets the goal of not leaking PII, but has the consequence that sometimes debugging can be difficult.
fields, on the other hand, are treated differently. Their values are hashed, and this hash is printed. This allows one to distinguish between unique values in log files, without compromising user privacy.

The Thrift annotations

are also accepted by the compiler.

The Thrift example above leads to code similar to the following:

public final class User implements Struct {
    fieldId = 1,
    required = true)
  public final String email;

@ThriftField( fieldId = 2, required = true) @Redacted public final String ssn;

// more code

@Override public String toString() { return "User{email=" + ObfuscationUtil.hash( + ", ssn=}"; }

// more code }

Obfuscated fields that are collections are not hashed; instead, their type is printed, along with the collection size, e.g.


Close readers will note that the compiler will also respond to

in field documentation; this is currently valid but not supported and subject to change in future releases. It is a legacy from the time before Thrifty implemented Thrift annotations.

Kotlin Support

As of version 1.0.0-RC1, Thrifty supports generated Kotlin code that is (almost) as small as its Java counterpart. Instead of classes with final fields, Thrifty Kotlin structs are represented as

data class
structures whose members are annotated as
. This produces classes which, when compiled, are nearly as small as their Java counterparts; the
class above looks like this in Kotlin:
data class Query(
  @ThriftField(fieldId = 1, required = true)
  val text: String,

@JvmField @ThriftField(fieldId = 2, optional = true) val resultsNewerThan: Long? ) : Struct {

override fun write(protocol: Protocol) { ADAPTER.write(protocol, this) }

private class QueryAdapter : Adapter { override fun read(protocol: Protocol): Query { // deserialization code as above }

override fun write(protcol: Protocol, struct: Query) {
  // serialization code as above


companion object { @JvmField val ADAPTER: Adapter = QueryAdapter() } }

Notice that, thanks to data classes, there are no longer custom

, or
methods. Because we can accurately model required/optional in the Kotlin type system, we no longer require builders to enforce struct validity - if you can instantiate a Thrifty Kotlin struct, it is valid by definition.

Also note that redacted and obfuscated fields are still supported, and will result in a custom


How To Enable Kotlin


to your thrifty-compiler.jar invocation, and add the

Kotlin-specific command-line options

There are a few new command-line options to control Kotlin code generation:

java -jar thrifty-compiler.jar \
    --lang=kotlin \
    --kt-coroutine-clients \
    --experimental-kt-builderless-structs \
    --kt-file-per-type \
    --omit-file-comments \

The new option

accepts either
; use the latter to generate Kotlin code.

By default, standard callback-based service clients will be generated:

interface Google {
  fun search(query: Query, callback: ServiceMethodCallback>)

If, instead, you wish to have a coroutine-based client, specify

interface Google {
  suspend fun search(query: Query): List

Although builders are no longer strictly necessary, for compatibility with existing code, Thrifty will still generate them by default. You can suppress them with the

flag, which (as its name suggests) is currently considered "experimental".

The final new flag is

. Thrifty's convention is to generate a single Kotlin file per distinct JVM namespace. For particularly large .thrift inputs, this is suboptimal. Outlook Mobile's single, large, Kotlin file took up to one minute just to typecheck, using Kotlin 1.2.51! For these cases,
will tell Thrifty to generate one single file per top-level class - just like the Java code.

suppresses the comment that prefixes each autogenerated Java file.


Thrifty owes an enormous debt to Square and the Wire team; without them, this project would not exist. Thanks! An equal debt is owed to Facebook and Apache for developing and opening Thrift to the world.

Copyright © Microsoft Corporation

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.