This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

Your Story is a Flutter mobile app for interactive fiction powered by local Gemma 4 models.

The app starts from structured story templates, then lets players act in natural language. Instead of branching only through fixed choices, the player can type actions like "I hide the beans and tell Mother the truth" or "I ask the giant's wife for help." The story engine evaluates what is possible, Gemma 4 writes the next passage, and deterministic state logic records permanent consequences.

The goal is to make AI storytelling feel less like a loose chatbot and more like a playable novel:

• formal beat structure keeps pacing coherent
• entity state tracks relationships, inventory, locations, and decisions
• Gemma 4 writes contextual prose and dialogue
• autosave preserves each turn
• local inference keeps core play available without depending on a server

The first story is Jack and the Beanstalk, with 13 beats, 6 characters, 7 locations, and a state model for choices such as trading the cow, taking treasure, earning trust, or angering the giant.

Demo

Video walkthrough: https://github.com/tuandinh0801/your-story/blob/main/docs/assets/your-story-mobile-demo.mp4

Planned walkthrough:

• open the story library
• start Jack and the Beanstalk
• choose local Gemma 4 mode
• play several natural-language turns
• show character and journal state updating from choices
• show router/model status for local and cloud agent routes

Code

Repository: https://github.com/tuandinh0801/your-story/tree/main

How I Used Gemma 4

Gemma 4 powers the core storytelling loop. It is not just used for a side feature.

I use two local Gemma 4 LiteRT-LM models through flutter_gemma:

The app also has a Firebase AI cloud route for fallback and enhanced tasks. Each agent request declares a routing policy:

• local fast for latency-sensitive story turns
• local quality for richer narration
• cloud quality for complex branching or when local is unavailable
• cloud image route for visual generation work

The router records which backend and model served each request. That makes the multi-agent system visible for debugging while keeping the reader experience simple.

Why Gemma 4 fits this project

Interactive fiction needs low-latency language generation, but it also needs long-running coherence. A pure cloud chatbot can produce prose, but it can drift from prior choices. A fixed branching engine can preserve state, but it limits the player's imagination.

Your Story splits the job:

• Gemma 4 handles prose, dialogue, interpretation, and summaries.
• Dart engine code handles state, preconditions, effects, beat progression, persistence, and validation.
• Context packing keeps the current world, beat, memories, and action inside the model budget.

This lets Gemma 4 do the creative language work while the app keeps the world consistent.

What makes it original

The app treats a story like a living state machine, not a chat transcript. The AI receives story rules and state context, then the engine validates what changed. Choices become durable facts that later turns can reference.

For example, if Jack trades Daisy for beans, that inventory change and relationship impact are stored as state. Later narration can reflect Mother's disappointment or trust because those values are no longer just text in an earlier paragraph.

Technical highlights

• Flutter mobile app with Riverpod.
• Local Gemma 4 E2B/E4B through flutter_gemma.
• Firebase AI fallback route.
• Drift for relational story state.
• Hive for long prose and summaries.
• Pure Dart engine for beat progression and effect validation.
• Template-driven story format.
• Mobile design system built around a calm storybook reading experience.