STAY - Keep the Days You Got

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

Dogs don't stay long enough.

That is the entire idea behind STAY.

STAY is an interactive experience about time, attention, and memory. It compresses the life of a dog into a few minutes, lets you experience the small choices that make up that life, and then gives you a way to preserve the moments that mattered.

The experience begins with Milo as a puppy.

You spend his life making ordinary decisions:

• take the walk
• finish some work
• play for a while
• take the photo
• go somewhere new
• stay home
• give him the shoe he already destroyed anyway

There is no perfect route.

There is no "good owner" score.

Life keeps moving either way.

Milo grows from puppy to young dog, adult, mature dog, and eventually senior.

His behaviour changes with him.

He reacts quickly when he is young.

He becomes calmer as he grows.

Familiar toys and places return years later.

His movements slow down.

And somewhere in the interface, the number of days he has left keeps falling.

The thesis behind STAY is simple:

You cannot give a dog more years. You can give their years more life.

Eventually, Milo's life ends.

There is no dramatic death animation.

For the whole experience, you have learned to expect Milo to occupy part of the screen.

Then that space is empty.

What remains are the moments you chose to keep.

Those memories can be preserved as a verifiable proof on Solana devnet.

But STAY does not end with simulated Milo.

After his Memory Box is complete, the experience asks one final thing:

Milo's story was simulated. Yours isn't.

From there, users can photograph or upload a real moment with their own dog, add a name, date, and short note, and create a cryptographic attestation for that memory.

The photograph itself does not need to live on-chain.

Instead, STAY hashes the image locally, creates a deterministic memory manifest, and commits the proof through a real Solana transaction.

The day will still disappear.

The proof that it happened does not have to.

Demo

🔗 Live Demo: https://stay-coral-gamma.vercel.app

STAY includes a Demo Mode that accelerates the real simulation so judges can experience the full arc without replacing the underlying state machine with hardcoded screens.

The complete journey is:

Meet → Live → Choose → Age → Remember → Lose → Preserve → Bring It Into Real Life

For the strongest experience, use a desktop browser first.

Code

🔗 GitHub: https://github.com/xyzbutworse/dog-years

The repository includes:

• the full interactive experience
• the life simulation/state system
• Milo's age-based behaviour
• memory generation
• local persistence
• deterministic manifest generation
• SHA-256 hashing
• Solana devnet proof flow
• real-memory attestation
• verification logic
• setup and architecture documentation

How I Built It

I started STAY with one constraint:

Solana could not be something I bolted onto the project at the end just to enter a prize category.

If removing Solana left the central concept unchanged, the integration was not meaningful enough.

So instead of using blockchain for the dog's life itself, I used it for the part of the experience concerned with permanence.

The dog is temporary.

The moment is temporary.

The proof can remain.

A Life Built From Small Choices

The first half of STAY is an authored dog-life simulation.

Milo progresses through multiple life stages and encounters events such as:

• his first walk
• a destroyed shoe
• rainy afternoons
• birthdays
• trips
• favourite toys
• photographs
• familiar parks
• quiet workdays
• slower mornings
• his final chapter

The user makes small choices throughout those moments.

Those decisions feed the same underlying life state.

STAY tracks values such as:

• shared days
• walks
• play
• work
• treats
• adventures
• photographs
• memories

Some decisions return later.

A toy introduced when Milo is young can become a worn object years later.

A park can feel different because you have already spent time there.

The goal was to make his life feel like one continuous history rather than a sequence of unrelated prompts.

Milo Is Part of the Interface

I did not want Milo to feel like an illustration sitting next to a web application.

He is the visual anchor of STAY.

The interface reacts around him.

His attention can follow the visitor or objects inside scenes.

His behaviour also changes as he ages.

Puppy Milo is restless and responsive.

Adult Milo is calmer.

Senior Milo reacts more slowly and spends more time resting.

The interface does not need to announce:

Milo is getting old.

You begin to notice it.

That becomes especially important during the ending.

For most of the experience, Milo is always there.

Then he isn't.

The absence is the storytelling.

Memories, Not Scores

When Milo's life ends, STAY does not rank the player.

Instead, it reconstructs the life they actually experienced.

It shows:

• how long Milo lived
• how many days were shared
• which experiences happened
• which memories survived

The user can then choose the memories they want to preserve.

Those selected moments form a canonical memory manifest.

STAY then generates a SHA-256 hash from that manifest.

That hash becomes the compact proof of the exact memory set.

Preserving Milo's Life on Solana

The Solana flow is deliberately small.

STAY can commit information such as:

• proof version
• life ID
• owner wallet
• memory count
• manifest hash
• completion timestamp

to a real transaction on Solana devnet.

When the transaction confirms, STAY displays the real signature and verification information.

The proof can be independently inspected through Solana Explorer.

The application never fabricates a transaction.

If a wallet is unavailable or the user chooses not to submit anything on-chain, STAY still allows a local version of the experience.

That state is explicitly labelled:

LOCAL PREVIEW - NOT ON-CHAIN

A successful blockchain preservation is separately shown as:

VERIFIED ON SOLANA DEVNET

The distinction is intentional.

A demo should never pretend to be blockchain activity.

PRESERVE TODAY

The final part of STAY is where the fictional story becomes personal.

After completing Milo's life, the user sees:

MILO'S STORY WAS SIMULATED.
YOURS ISN'T.

They can then preserve one ordinary day with their real dog.

The flow is simple:

1. take or upload a photograph
2. enter the dog's name
3. add a short note
4. confirm the date
5. create the memory proof

The image is hashed locally using SHA-256.

STAY then creates a deterministic manifest containing the image hash and associated memory data.

The photograph itself remains off-chain.

Solana stores or commits to the proof.

That separation is important.

STAY is not pretending a blockchain is a photo-storage service.

Instead:

the image contains the memory

and

Solana proves the integrity of that memory

The proof can include information such as:

• memory ID
• image hash
• manifest hash
• wallet
• timestamp
• proof version

If the canonical image changes, the image hash changes.

If the memory metadata changes, the manifest hash changes.

That means the original memory can later be checked against its recorded proof.

Verification

STAY includes verification logic for preserved memories.

The application can:

• load the memory
• recompute the image hash
• reconstruct the canonical manifest
• generate the manifest hash again
• compare those values with the stored proof
• show whether they match
• expose the associated Solana transaction when one exists

A modified image should no longer produce the same proof.

This turns the Solana integration into something inspectable rather than decorative.

The Memory Box

Preserved moments live inside a Memory Box.

I intentionally avoided presenting them as NFTs or a crypto portfolio.

The visual language is closer to a physical archive:

• photographs
• dates
• annotations
• familiar objects
• warm paper
• fragments from Milo's life

Technical details are still available for verified memories:

• memory ID
• image hash
• manifest hash
• owner wallet
• network
• Solana transaction signature

But those details are secondary.

The emotional object is the memory.

The blockchain is the receipt.

Visual Direction

I wanted STAY to feel nothing like a conventional Web3 application.

So I deliberately avoided:

• crypto dashboards
• token charts
• purple gradients
• glassmorphism
• card-heavy layouts
• wallet-first onboarding
• NFT marketplace aesthetics

The visual direction is closer to an interactive editorial piece or small narrative game.

It uses:

• large character-led compositions
• warm paper textures
• photography
• restrained typography
• subtle motion
• physical-memory references
• objects that gain meaning because they return later
• Milo as a persistent character rather than a mascot

The wallet only becomes important once there is something worth preserving.

That was intentional.

Technology should not interrupt the life.

It should matter when the life becomes a memory.

Prize Categories

Best Use of Solana

STAY is submitted for Best Use of Solana.

The core blockchain loop is:

life → memories → canonical manifest → SHA-256 hash → Solana transaction → verification

For a real dog, that becomes:

real moment → photograph → image hash → deterministic memory manifest → Solana attestation → independently verifiable memory

There is no token.

There is no marketplace.

There is no "mint your dog" mechanic.

STAY uses Solana because the project ultimately asks one question:

What can remain after a moment is gone?

The blockchain is not the story.

It is proof that the story existed in that exact form.

Dogs have a strange relationship with time.

They arrive and become part of the routine so quickly that it feels permanent.

Walks.

Shoes.

Rainy afternoons.

Photos you almost didn't take.

Sleeping beside your desk while you work.

Then eventually those ordinary days become the things you remember most.

STAY is about noticing them before that happens.

They cannot stay forever.

The memory can.