How Kallo Came to Be

It started with a problem I couldn't solve cleanly

A while back — before AI tooling was something you reached for every day — I was working on a Flutter project that needed real SIP voice calling. Not video chat, not a browser demo: plain, native calling that could talk to an existing telephony backend. I went looking for something to drop in, and came up almost empty. Nearly everything pointed me toward WebRTC, and WebRTC just didn't fit what I needed. It's built for a different problem, and bending it toward native SIP felt like fighting the tool the whole way.

So I did the pragmatic thing. I found a native SIP engine — a mature, capable one — and built a Flutter layer on top of it so my app could actually place calls. It worked. But the experience left a splinter in my mind that I couldn't quite remove.

The splinter: this is more than I need, and it costs more than it should

The engine I'd built on was powerful, but that was part of the problem. It shipped with far more than my use case ever asked for — a huge surface of features I would never touch — and it came with a cost structure that didn't make sense for what I was actually doing. I kept looking at it thinking: I'm carrying all this weight and paying for all this capability to do one fairly focused thing.

That's when the thought first showed up, the one that never fully leaves once it arrives: why not build my own? Something lean. Something shaped exactly like the problem instead of ten problems next to it. Something I understood end to end.

The wall: I didn't have the C knowledge

The trouble was that "build my own" ran straight into a wall. The real work of native SIP lives down in C — the kind of low-level, memory-careful code I simply hadn't written. I could design a nice Dart API all day, but the engine underneath it was a language and a discipline I didn't have. So the idea did what a lot of good ideas do: it went on the shelf. Not abandoned, just... parked. I'd take it down every so often, look at it, and put it back.

The turning point

What changed wasn't that I suddenly learned C in a weekend. What changed was that AI tooling got good enough to make the gap bridgeable. Not erased — bridgeable. Suddenly the thing that had blocked me for so long felt like something I could actually approach: I could reason through unfamiliar native code, ask questions in the middle of it, and make progress where before I'd have simply stopped. I decided to stop theorizing and just try, and see where it led.

The honest part: it was not "prompt it and forget it"

I want to be clear about this, because the easy version of this story is a lie. This was not a case of typing a prompt and receiving a finished SDK. It was a long stretch of trial and error — builds that didn't work, calls that connected but stayed silent, subtle problems that took real time to understand and fix. AI was a genuine accelerant, but I was still the one who had to steer, test, and make the calls.

And along the way I ended up learning a pile of things I'd never done before. I stood up my own SIP server to have something real to test against. I learned how to actually verify that calls registered, that audio flowed both ways, that the signaling and the media were doing what they claimed. And I learned the unglamorous craft of publishing a real package that other developers could depend on — the packaging, the versioning, the discipline of shipping something that has to keep working. None of that is glamorous, and all of it mattered.

Where it landed

The result is Kallo: a closed-binary Flutter SDK for native SIP voice calling, on both Android and iOS, secured with TLS and SRTP, delivered as a single package that just works on both platforms. It's now at a stable 0.1.16 — a version I'm actually comfortable putting in front of people. There's a portal with docs and licensing so a developer can request access and get going without me in the loop.

I'm not going to overstate where it is. It's early, and it's honest about that. But it exists, it's stable, and it does the specific thing I once went searching for and couldn't find: real native calling in Flutter, without carrying an entire telephony platform to get it.

If you build in Flutter and you've ever needed proper voice calling, I'd love for you to try it. You can find the docs and request access at kallosdk.com.