Collins Munene
Senior Software & DevOps Engineer at Shipht
Nairobi, Kenya
Actions
Collins Munene is a Senior Software & DevOps Engineer at Shipht, where he builds and runs scalable, high-performance systems across the full stack, from cloud infrastructure on AWS and Azure to native mobile apps.
His work sits where backend and client meet: designing cloud-native services, exploring Server-Driven UI (SDUI), and making sure what reaches the user’s screen is fast and efficient. He works mainly with Kotlin, .NET, and Flutter, with a strong focus on Android rendering performance.
Collins enjoys digging into how systems behave under load, whether that’s a cloud deployment or a GPU frame budget, and helping teams ship faster with confidence.
Area of Expertise
Topics
Beyond Skia: Deep-Dive GPU Scheduling and Profiling with Impeller on Android 10+
Flutter can make it easy to build complex interfaces, but keeping those interfaces smooth at 120 FPS is a different challenge. In this session, we'll look at what happens when a Flutter application starts doing too much work during rendering.
We'll build and deliberately stress a Flutter graphics canvas using complex paths, expensive painting operations, multiple layers, and unnecessary repaints. Once the application starts dropping frames, we'll use Flutter DevTools and Android Perfetto to find out why.
Rather than looking at performance as a collection of rules, we'll follow the evidence in the traces. We'll identify whether the problem is coming from the UI thread, raster thread, or GPU, and then make targeted changes to the code and measure the results.
Along the way, we'll explore how Impeller's rendering pipeline works on Android, how CustomPainter and canvas operations affect performance, and where tools such as RepaintBoundary can help.
By the end of the session, attendees will have a practical workflow for taking a Flutter rendering problem from "it feels janky" to a measurable performance improvement.
Key Takeaways
• Understand the basics of how Impeller renders Flutter graphics on Android.
• Use Flutter DevTools and Android Perfetto to investigate frame drops.
• Identify expensive painting, layers, and unnecessary repaints.
• Apply practical optimizations to CustomPainter-based interfaces.
• Measure rendering improvements instead of relying on guesswork.
Beyond the APK: Streaming Native UI with Kotlin Remote Compose (Workshop)
In a mobile landscape as dynamic as Africa’s, speed is everything. Traditional release cycles are bottlenecks for innovation. This hands-on workshop dives into the future of Server-Driven UI (SDUI) using the experimental androidx.compose.remote library.
Instead of just talking about "streaming UI," we are going to build the entire pipeline from scratch. Participants will step through the creation of a native UI engine that allows for instant, over-the-air updates without the "APK tax."
In this workshop, we will build:
The UI Producer (Backend): A Kotlin JVM service that defines layouts using the Remote Compose DSL and compiles them into optimized .rc binary files.
The UI Consumer (Android App): An application integrated with the RemoteComposePlayer to fetch, decode, and render those binaries natively on the Canvas.
Dynamic Bridges: Implementing "Actions" to handle button clicks and navigation between remote-driven components and local app code.
What you will learn:
How to architect a secure and versioned SDUI system.
The performance benefits of binary UI bytecode over JSON-mapping.
Debugging techniques for remote-rendered components.
Prerequisites for Attendees:
A laptop with Android Studio installed.
Basic familiarity with Jetpack Compose.
A starter project (link to be provided) cloned and synced.
Beyond Skia: Deep-Dive GPU Scheduling and Profiling with Impeller on Android 10+
With Flutter’s definitive transition to the Impeller rendering engine, the ecosystem has achieved a predictable, ahead-of-time (AOT) shader-compiled execution model. However, hitting a rock-solid, fluid 120fps on modern high-refresh-rate Android devices requires engineers to shift how they diagnose, isolate, and fix rendering bottlenecks.
This session bypasses high-level UI paradigms to dissect exactly how Impeller interacts with the modern Vulkan graphics API on Android 10+ (API 29+). We will dive into how Impeller schedules GPU pipelines, uses modern tessellation to break vector paths into fast-rendering triangles, and manages explicit command buffers to prevent frame drops under heavy stress loads.
we will intentionally thrash a real-time graphics canvas and step through deep-dive profiling.
Attendees will learn how to parse advanced Flutter DevTools Timeline traces, interpret Android Systrace/Perfetto metrics, and engineer surgical UI optimizations—such as precise repaint boundary isolation and layer complexity reduction—to confidently ship enterprise-grade mobile experiences.
Key Takeaways:
- Demystifying the Engine: Understand the architectural differences between Skia’s JIT shader compilation and Impeller’s AOT pipeline mechanics on Vulkan.
- Low-Level Profiling: Master advanced Flutter DevTools and Android Systrace to read frame-budget allocations (~4ms UI / ~4ms Raster thread).
- Taming Custom Painters: Learn code patterns that maximize Impeller's pre-compiled rendering pathways, avoiding expensive canvas operations like saveLayer().
Collins Munene
Senior Software & DevOps Engineer at Shipht
Nairobi, Kenya
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top