One question gets asked in Filipino households all the time:
"Ano ang lulutuin natin?"
Sometimes you already know.
Sometimes you don't.
And sometimes the weather gives you a pretty good idea.
Rainy afternoon?
Maybe Sinigang.
Cold weather?
Maybe Bulalo.
Hot afternoon?
Maybe Halo-Halo.
That simple observation became the idea behind one of my projects:
Lutong Simmer.
What Is Lutong Simmer?
Lutong Simmer is a Filipino cooking companion application that uses weather and time of day to recommend Pinoy food.
Instead of simply searching for recipes, the application uses context.
It considers things like:
Current weather
Local time
Dietary needs
Ingredients
Filipino recipes
The basic idea is:
Weather + Time + User Context
↓
Recommendation
↓
Filipino Food
It's a simple concept, but building it introduced me to several interesting Android development problems.
Why Use Weather?
Weather isn't usually the first thing you associate with a recipe application.
But it makes sense when you think about how people actually choose food.
A rainy day can make a warm soup more appealing.
A hot day can make something refreshing more attractive.
So I decided to make weather part of the application's experience instead of treating it as unrelated information.
The app integrates weather data and uses it as part of the context for its recommendations.
Building It With Kotlin
Lutong Simmer is a native Android application built entirely with Kotlin.
The stack includes:
Kotlin
Jetpack Compose
Material 3
Room
Coroutines
Flow
Coil
Google Gemini API SDK
The architecture follows an MVVM approach with Unidirectional Data Flow.
The general flow looks like:
Data
↓
Repository
↓
ViewModel
↓
StateFlow
↓
Compose UI
This keeps the UI focused on displaying state while the underlying logic stays separated.
Offline-First
One of the things I wanted from the beginning was for the app to remain useful without a constant internet connection.
That's why Lutong Simmer uses Room SQLite for local persistence.
Saved and locally stored recipe information can remain accessible even when the network isn't available.
This matters more than it might seem.
Imagine you're already cooking.
You open the app.
The Wi-Fi doesn't work.
You shouldn't lose access to your recipes.
So offline support became part of the product design.
Search Optimization
The application also has local SQLite search with a debounce mechanism.
Without debouncing, typing something like:
Sinigang
could result in multiple database operations:
S
Si
Sin
Sini
Sin...
Instead, the application waits briefly for the user to stop typing before performing the search.
It's a small optimization.
But these small optimizations add up when you're trying to make an application feel responsive.
Kitchen Studio
Lutong Simmer also lets users create their own recipes.
I called this feature Kitchen Studio.
Users can create custom Filipino recipes and save them locally.
They can also attach photos using:
Camera
Gallery
The cooking instructions can then be interacted with through a checklist.
So instead of simply reading:
Step 1
Step 2
Step 3
the user can actually track their progress while cooking.
Making It Feel Filipino
I didn't want to build a generic recipe app and simply replace the recipes with Filipino dishes.
I wanted the application to have its own identity.
The interface uses a custom culinary-inspired palette:
Terracotta Orange
Golden Honey
Sage Green
It also includes localized greetings such as:
Magandang Gabi, Ka-simmer!
These details are small.
But together, they make the application feel more intentional.
The UI
The application is built using Jetpack Compose and Material 3.
I also experimented with custom animations.
One of them is an animated empty state.
Instead of simply showing an empty screen when a search returns nothing, the UI displays:
A pulsing icon
Rotating dashed ring
Centered messaging
Clear-search action
I also paid attention to recipe card layouts.
Long recipe names can easily break grid interfaces, so the cards use:
maxLines = 1
TextOverflow.Ellipsis
This keeps the layout consistent.
Where Gemini Comes In
Lutong Simmer also integrates Google's Gemini API.
The AI component helps with contextual recipe generation and recommendations, particularly around ingredients.
This was another lesson for me.
I don't think every application needs AI.
Adding an AI API doesn't automatically make a product better.
The better question is:
Where can AI actually solve a problem for the user?
For Lutong Simmer, that problem is generating useful recipe-oriented results from context and ingredients.
What I Learned
This project taught me to think about context.
My previous projects taught me different things.
Train Track made me think about user journeys.
HackForPinas made me think about data aggregation, security, and automation.
Lutong Simmer made me think about how software can react to a user's situation.
The application isn't only asking:
"What recipes do we have?"
It's asking:
"What might make sense for this person right now?"
That changed how I think about recommendation systems.
More Than a Recipe App
Technically, Lutong Simmer could be described as:
A Kotlin Android application using Jetpack Compose, Room, weather data, and Gemini.
But that's not really how I think about it.
I see it as an experiment in combining:
local culture + contextual data + mobile technology + AI.
The technology is important.
But the idea behind the technology matters more.
What's Next?
After working on food, I wanted to move into something completely different.
My next project explores cameras, image processing, and visual computing.
That's ScreenFrame.
Instead of asking:
"What should I cook?"
the next application asks:
"What can software understand from an image?"
And that introduced me to a completely different set of engineering problems.
Top comments (0)