Square Built Android. JetBrains Rebuilt It: Why Android Architecture Is Shifting in 2026

From Hilt vs Koin to Retrofit vs Ktor — how the philosophical battle between Block and JetBrains shaped modern Android development.

Image generated by AI

The Hidden Story Behind Android’s Most Popular Libraries

Android developers often debate technical questions like:

• Should I use Hilt or Koin?
• Is Retrofit still the best networking choice?
• Is Ktor the future?

At first glance, these seem like normal library comparisons.

But underneath them is a deeper industry shift.

This is really a story of two competing philosophies.

On one side:

The Android ecosystem built by Block (formerly Square), whose engineering culture shaped Android through libraries like:

• Retrofit
• OkHttp
• Moshi
• Dagger (strongly adopted by Android teams)

This ecosystem prioritized:

• Practicality
• Performance
• Battle-tested engineering
• Large-scale Android production needs

On the other side:

The Kotlin-first world shaped by JetBrains, creators of:

• Kotlin
• Ktor
• Kotlin Multiplatform
• The language philosophy influencing libraries like Koin

This ecosystem emphasizes:

• Language-native design
• Developer ergonomics
• Cross-platform future-proofing
• Declarative architecture

The Hilt/Koin and Retrofit/Ktor debates are really reflections of this larger transition.

Android isn’t just choosing libraries anymore.

It’s choosing its future.

Square’s Legacy: Why Retrofit and Hilt Feel So “Android-Native”

To understand why many Android developers still default to Hilt + Retrofit, we need to understand what Square built.

For over a decade, Square’s open-source libraries defined Android best practices.

When Android networking was fragmented, Retrofit made API calls elegant.

Instead of manual request construction, developers could simply write:

interface ApiService {
    @GET("users")
    suspend fun users(): List<User>
}

That design changed Android.

It was:

• Simple
• Predictable
• Readable
• Easy to scale

The same applies to OkHttp.

Even today, much of Android networking still relies on it under the hood.

Then there’s dependency injection.

While Hilt is a Google product, it inherits much of its philosophy from Dagger:

strict compile-time guarantees.

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
)

This approach reflects classic large-scale backend engineering principles:

Catch errors before runtime.

That’s exactly the mindset companies like Square needed.

When your app serves millions of financial transactions, runtime surprises are expensive.

This is why Android teams at scale often still favor:

Hilt + Retrofit

It represents mature Android engineering.

Stable.

Predictable.

Production-focused.

JetBrains’ Challenge: Kotlin-First Architecture

Then Kotlin happened.

And Android began changing from the inside.

When JetBrains created Kotlin, they didn’t just make Java nicer.

They introduced a new way to think about APIs.

Kotlin encourages:

• DSLs
• Concise syntax
• Type-safe builders
• Declarative patterns

This naturally gave rise to libraries like Koin.

Instead of annotation-heavy setup:

val appModule = module {
    single<UserRepository> { UserRepositoryImpl() }
    viewModel { UserViewModel(get()) }
}

No generated code.

No hidden machinery.

Just Kotlin.

That simplicity matters.

Especially for solo developers and small teams.

The same philosophy appears in Ktor.

Unlike Retrofit’s declarative interfaces, Ktor gives you composable control.

val client = HttpClient {
    install(ContentNegotiation) {
        json()
    }
}

This is not just an API design difference.

It reflects a different worldview.

Retrofit asks:

“What endpoint are you calling?”

Ktor asks:

“What kind of client do you want to build?”

That flexibility becomes powerful in:

• Shared KMP networking
• Custom pipelines
• Cross-platform architecture

JetBrains is betting that Android’s future is not Android-only.

And that changes everything.

Hilt vs Koin, Retrofit vs Ktor: The Real Trade-offs

Let’s strip away hype.

What actually changes when choosing between these ecosystems?

Hilt vs Koin

The honest answer:

• If your app is large and long-lived, Hilt’s strictness pays off.
• If speed matters more than architectural enforcement, Koin is easier.

Retrofit vs Ktor

Again:

• Retrofit wins for straightforward Android apps.
• Ktor wins when multiplatform enters the picture.

But the most interesting comparison is stack-level:

Traditional Android Stack: Hilt + Retrofit

Optimized for:

• Stability
• Team conventions
• Enterprise Android

Kotlin-First Stack: Koin + Ktor

Optimized for:

• Speed
• Flexibility
• Cross-platform future

This is Square vs JetBrains in architectural form.

Why 2026 Feels Like a Turning Point

For years, Android was essentially a Java ecosystem with Kotlin syntax.

That’s changing.

Three forces are accelerating the shift:

Kotlin Multiplatform

Shared business logic makes Ktor increasingly attractive.

Compose Mentality

Jetpack Compose normalized declarative APIs.

That makes developers more comfortable with Kotlin-native DSLs like Koin.

Developer Experience Matters More

Modern teams increasingly optimize for:

• Faster onboarding
• Simpler code
• Lower cognitive overhead

This benefits JetBrains-style tooling.

But here’s the important nuance:

The old stack isn’t going away.

Financial apps.

Enterprise systems.

Massive legacy codebases.

These still benefit enormously from the rigor of Hilt and Retrofit.

This is not replacement.

It’s diversification.

Conclusion

The Hilt vs Koin and Retrofit vs Ktor debates are not really about APIs.

They’re about two philosophies.

The Square / Cash App Philosophy

Engineering discipline first.

• Compile-time guarantees
• Explicit architecture
• Production stability

Represented by: Hilt + Retrofit

The JetBrains Philosophy

Developer fluency first.

• Kotlin-native APIs
• Flexible composition
• Cross-platform thinking

Represented by: Koin + Ktor

Which is better?

Neither.

Each optimizes for different constraints.

If I were starting:

• Android-only production app: Use Hilt + Retrofit
• Solo app / fast iteration: Use Koin + Retrofit
• Kotlin Multiplatform future: Use Koin or Hilt + Ktor

The real lesson is this:

• Android architecture is no longer about following one dominant path.
• For the first time in years, developers have genuine architectural choice.
• And that’s a sign the ecosystem is maturing.

Which side are you leaning toward in 2026?

Still riding the Square-era Android stack?

Or moving toward JetBrains’ Kotlin-first future?

The answer probably says more about your project roadmap than your library preferences.

[embed]Android History Through the Quotes That Changed It Android History Through the Quotes That Changed It How a Few Engineers Predicted the Future of Android The history of…levelup.gitconnected.com

Enjoyed this article? Here’s how you can support my work:

• 👏 Clap (up to 50 times!) if you found this insightful.
• 👤 Follow me and turn on notifications (🔔) so you never miss the next deep dive.
• 📧 Subscribe to get my latest stories delivered directly to your inbox.

You can find all my articles on Android architecture, Jetpack Compose, and Kotlin in this curated reading list.