A few weeks ago, I wrote about working on Cabal v3, a modern peer-to-peer chat app for Android, and how I started by exploring a React Native direction.
Later, I also wrote about how I started learning Kotlin by building a real Android app instead of only reading tutorials.
This post is the continuation of that series.
Today, I’m happy to share that the first early version of Cabal for Android is now available.
GitHub repository:
👉 https://github.com/johnnylemonny/cabal-android
An early version is also available to download from the repository.
What is Cabal for Android?
Cabal for Android is my attempt to build a modern Android client for Cabal as a native Kotlin application.
The idea is simple:
a peer-to-peer chat app for Android, built with modern native Android development in mind.
This project started as an experiment, but it quickly became something more serious for me. It became a way to learn Kotlin, understand Android development better, and explore how decentralized communication can feel on mobile.
From React Native exploration to native Kotlin
In the first post of this series, I wrote about reviving a P2P mobile chat app idea and experimenting with Cabal on Android.
At that point, I was thinking about the project from a React Native perspective.
That was useful because it helped me understand the shape of the app:
- what the UI could look like,
- how the chat flow should feel,
- what kind of mobile experience I wanted,
- and how much work would be involved in bringing a P2P chat app back to life on Android.
But after spending more time with the project, I decided to move deeper into native Android development.
That decision led me to Kotlin.
Why Kotlin?
Kotlin had been on my list for a long time.
I had read about it before. I had seen examples. I understood the basic syntax. But I never really learned it properly because I was missing one important thing:
a real project.
Cabal became that project.
Instead of learning Kotlin in isolation, I learned it by building something that had real screens, real state, real problems, and real trade-offs.
That changed everything.
Kotlin stopped being just a list of language features and became a tool I used every day to move the app forward.
What is included in this first version?
This is still an early version, but it is an important milestone.
The app is now at the point where it feels like a real native Android project instead of just an idea or experiment.
The first version focuses on the foundation:
- native Android structure,
- Kotlin-based implementation,
- a modern mobile app direction,
- Cabal-related chat experience,
- early downloadable build,
- and a codebase that can now evolve further.
It is not perfect yet.
It is not “finished” in the final-product sense.
But it is finished in the most important early-stage sense:
the project exists, runs, can be tested, and has a real direction.
That feels like a big step.
What I learned while building it
Building this first version taught me much more than I expected.
1. Real apps teach faster than tutorials
Tutorials are useful, but they usually have clean examples and predictable problems.
Real apps are different.
When building Cabal for Android, I had to make decisions about structure, state, screens, naming, data flow, and how to keep the app understandable as it grew.
That kind of learning is harder, but also much more valuable.
2. Kotlin makes Android development feel focused
One thing I started to appreciate is how Kotlin encourages more intentional code.
Null safety, data classes, immutability, and concise syntax all helped me think more clearly about the app.
At first, some parts slowed me down. But over time, those same features made the project feel safer and easier to reason about.
3. Native Android development has its own rhythm
Coming from other environments, native Android development requires a different mindset.
You are not only learning Kotlin.
You are also learning:
- Android project structure,
- lifecycle concepts,
- UI patterns,
- state handling,
- Gradle,
- app packaging,
- and how all of these pieces fit together.
That was challenging, but also one of the best parts of the process.
4. Small milestones matter
This version is early, but shipping it matters.
It is easy to keep waiting until everything is perfect.
But open-source projects grow better when they are visible early.
Putting this first version out there gives the project a real starting point.
Why this project matters to me
Cabal for Android sits at the intersection of a few things I care about:
- mobile development,
- Kotlin,
- Android,
- open source,
- peer-to-peer communication,
- and learning by building.
I like projects that are practical but also a little experimental.
A P2P chat app is exactly that kind of project.
It is not just another CRUD app. It forces you to think about networking, identity, local-first experiences, mobile constraints, and how users communicate without depending entirely on centralized infrastructure.
That makes it a fun and meaningful project to work on.
Repository and download
The project is available here:
👉 https://github.com/johnnylemonny/cabal-android
There is also an early downloadable version available from the repository.
If you are interested in Kotlin, Android, peer-to-peer apps, or open-source mobile development, feel free to check it out.
Feedback, ideas, and contributions are welcome.
What comes next?
This first version is only the beginning.
Next, I want to continue improving the app step by step:
- polish the UI,
- improve the chat experience,
- clean up the architecture,
- test more edge cases,
- improve stability,
- and continue learning Kotlin through real development.
I also want to keep writing about the process because documenting the journey helps me understand what I’m learning.
And maybe it helps someone else too.
Final thoughts
This project started as an experiment.
Then it became a Kotlin learning project.
Now it is becoming a real native Android app.
That progression has been very motivating.
The biggest lesson so far is simple:
If you want to learn a technology deeply, build something real with it.
Cabal for Android gave me a reason to learn Kotlin properly.
And now the first early version is here.
Thanks for reading — and if you try the app or look through the code, I’d love to hear what you think.
