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: take or upload a photograph enter the dog's name add a short note confirm the date 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