Kirple

Kirple is a cozy, AI-powered creature game where your interactions unlock animated memories. Each cat is uniquely generated with traits, art, and stories that grow as your bond deepens.

Comment 1

Inspiration

Kirple was inspired by cozy simulation games like Neko Atsume and Animal Crossing, where players passively interact with cute creatures in a relaxing world. We wanted to recreate that whimsical, comforting experience powered by AI. Our goal was to make each creature in the game feel alive through evolving personalities, memories, and interactions based on how players treat them. We also saw this as an opportunity to explore the intersection of generative AI, interactivity, and emotion in games.

What it does

Kirple is an AI-powered creature collection game where players attract and interact with unique creatures by placing toys, furniture, and food in a shared garden. Each creature has a personality generated from traits and a custom memory system. As the player engages more with a creature, it "remembers" meaningful events - unlocking new animations, diary entries, and emotional responses. These memories are stored chronologically and become more detailed with higher interactivity.

How we built it

  • Game Engine (Unity 2D):
    We used Unity as our core platform for game logic and visuals. Unity handles:

    • Scene management for player navigation through garden areas
    • Sprite switching for creatures based on pose/state (e.g., idle, eating, interacting)
    • Clickable objects like toys and furniture that trigger backend API calls
    • Animation states and transitions (using Animator Controllers) to reflect emotional growth
    • Object layout using Unity's canvas and sorting layers to create a cozy, isometric garden feel

  • AI Memory System:
    Google Gemini API generates creature descriptions and emotional memories based on traits and interactivity scores.

  • Database (MySQL):
    Stores player-creature interaction history, interactivity scores, memory unlocks, and trait schemas.

  • Backend (PHP):
    Handles fetching and updating data from Unity via HTTP requests, enabling persistent gameplay.

  • Version Control:
    Git & GitHub used for managing and syncing work across the team.

We created a memory generation pipeline where every creature has a set of traits (e.g., shy, playful, protective). When a player interacts with them enough to pass a certain interactivity threshold, we prompt the LLM to generate a warm, emotionally resonant memory. These memories are returned as structured arrays and saved to the creature’s profile in the database. Unlock thresholds are set at milestones like 10, 30, and 50 points.

Challenges we ran into

  • Unity animation logic:
    Sprite switching and animation layering were tricky, especially managing animator state transitions for different creature moods.

  • Scope management:
    With AI, backend, and game design components, we had to constantly scope and rescope to meet the hackathon deadline.

Accomplishments that we're proud of

  • Created a working memory unlock system that reflects emotional progression
  • Built a scalable Unity architecture for expanding creatures, environments, and interactions
  • Designed a database schema that supports tracking detailed player-creature bonding history

What we learned

  • How to integrate Unity with external AI and database systems
  • The importance of well-structured prompts when generating emotional, narrative-style outputs
  • How powerful even basic state transitions and sprite logic can be when creating the illusion of life
  • That cozy games can be technical - and that emotion in games can be coded just as much as it’s written

What's next for Kirple

  • Diffusion model sprite generation:
    We're planning to use a diffusion model (e.g., Stable Diffusion + ControlNet) to generate new creature sprites based on trait embeddings. This means players could one day “create” their own creatures with unique personalities and looks - all AI-generated.

  • AI-powered personalization:
    Use player interaction history to dynamically evolve creature personalities and suggest new items they might love.

  • Mobile optimization:
    Build and test a mobile-friendly version of Kirple with touch-first UI for cozy play on the go.

  • Seasonal events and lore drops:
    Add worldbuilding and time-based events that unfold collectively across players.

  • Reinforcement learning integration:
    In future versions, explore RL-based behavior systems where creature responses adapt more intelligently to player input.

Share this project:

Updates