Kippo

Kippo started as a gaming-focused dating app. The team wanted to take it further — to build a shared game world inside the app where users could actually play together, move through social spaces, and interact in real time. The idea was solid. The problem was that Unity needed to live inside an already-shipping native iOS and Android app without breaking anything that was already working.

I was the sole senior Unity developer. Three months. The result: a multiplayer social game layer embedded in a live app, contributing to 500K+ Google Play downloads and a $4.5M investment round.

Embedding Unity into an existing native app is not the same as building a Unity app. The native app owns the lifecycle, the permissions, the UI chrome, and the app store identity. Unity has to live inside that — launching when asked, communicating both ways, and shutting down cleanly without destabilising the host application.

The iOS side required UnitySendMessage and a Swift bridge. The Android side required AndroidJavaClass. Two different platforms, two different architectures, both needing to feel seamless to a user who had no idea Unity was involved.

Performance was the secondary constraint. The user base spanned low-spec Android devices. Whatever was built needed to run without hitches on hardware that was three or four years old.

• Designed the complete game world architecture — social hub, environments, player flow
• Built all player movement and interaction systems
• Designed and shipped 8 mini-games with PlayFab scoring and leaderboards
• Built all in-game UI within Unity
• Embedded Unity into the native iOS app via UnitySendMessage and Swift bridge
• Embedded Unity into the native Android app via AndroidJavaClass
• Implemented bridge communication between the dating app's native systems and Unity
• Integrated Photon multiplayer for real-time shared social environments
• Integrated Agora for voice and video communication between players
• Applied SpriteAtlas, Static Batching, and ObjectPool optimisations for low-spec devices
• Collaborated directly with native iOS and Android engineers on the host app
• Worked on-site at Kippo's office in Los Angeles during production

The architecture question was how Unity should live inside the native app. Two approaches were viable: a deep integration where Unity owned most of the UI, or a minimal integration where Unity handled only the game world and communicated back to native code for everything else.

The shallow integration won. Unity controlled the game scene; the native app controlled the UI chrome, navigation, permissions, and app store identity. The two communicated via UnitySendMessage on iOS and AndroidJavaClass on Android. The reasoning was straightforward: the app was already live with a real user base. Anything that destabilised the native layer would have been immediately visible to users. The minimal integration kept the risk surface small, gave the native engineers confidence that their code wasn't being replaced, and meant that a bug in the Unity side couldn't take down the host app.

It was also faster to build, which mattered — three months was not a long runway.

This is the type of work that rarely comes with a press release. The user experience was a social game. The engineering reality was: multiplayer networking, voice/video integration, two native app platforms, performance optimisation, and a UI system — all built by one person, in three months, inside a live app that could not break.

The download numbers and investment round are the public record. It shipped on time, inside a live app, without breaking anything.

• Kippo official website
• Kippo on Google Play — 500K+ downloads