I Built a Tiny Cat That Breathes With You, Using Just a Webcam 🐈

This is a submission for the Presage SmartSpectra SDK Challenge.

What I Built

What if your breathing could bring a tiny creature to life?

Not through a microphone. Not through a wearable device. Not even through a button.

Just you, your webcam, and a little black cat.

Meet PAWSE. 🐈💚

A little companion that breathes with you.

PAWSE is an open-source desktop experience powered by the Presage SmartSpectra SDK. It transforms physiological signals captured through an ordinary camera into the movements of a hand-drawn virtual companion.

When you breathe, PAWSE breathes at your measured respiratory rate.

When your heart beats, a tiny light on its chest pulses at your measured heart rate.

And when you spend a quiet minute together, your little companion curls up and goes to sleep.

No fitness goals. No scores. No pressure to improve your numbers.

Just 60 seconds of paying attention to your breathing, with a little company.

Why a cat?

I wanted to explore a simple question:

Can biometric technology create an emotional connection instead of another dashboard?

Most physiological monitoring experiences are built around numbers, charts, and measurements.

I wanted to build something different.

Something playful. Something that feels alive. Something that makes people smile when they realize their own breathing is influencing a tiny creature on their screen.

That's how PAWSE was born.

The experience

PAWSE takes users through four simple moments.

1. Meet PAWSE 🐾

A sleepy black cat greets you. Before anything starts, PAWSE explains how it uses your camera and asks for explicit consent.

2. Wake up PAWSE 👀

With your permission, SmartSpectra begins measuring physiological signals.

The cat becomes curious, opens its eyes, and waits for a stable respiratory reading.

3. Breathe Together 💚

For 60 seconds, PAWSE follows your measured breathing rate.

Its belly gently expands and contracts. A subtle chest glow follows your pulse. Its ears twitch, its tail sways, and its eyes wander around its little world.

If your respiratory rate changes, its breathing animation gradually adapts.

If the signal becomes unavailable, the timer pauses rather than pretending everything is fine.

4. A Little Moment of Peace 🌙

After 60 seconds of valid measurement, PAWSE closes the camera, curls up, and falls asleep.

A few tiny hearts appear.

And the screen says:

"You gave PAWSE a little moment of peace. 💚"

That's it.

Sometimes technology doesn't need to ask us to accomplish more.

Sometimes it can simply invite us to spend a moment with ourselves.

Demo

The demonstration shows PAWSE running as a real Electron desktop application using a webcam and live SmartSpectra measurements.

It highlights:

• Explicit camera consent and session initialization.
• Real-time respiratory rate and pulse measurements.
• The cat's breathing animation responding to changes in measured respiratory rate.
• Subtle heartbeat and personality animations.
• The complete 60-second Breathe Together experience.
• The final moment when PAWSE curls up and rests.

This is a real SmartSpectra integration, not a prerecorded animation.

For transparency, PAWSE also includes a development-only simulation environment. Simulated readings are clearly labeled and are never presented as real measurements.

The development simulator does not call SmartSpectra or consume API credits.

Code

🐈 GitHub Repository: https://github.com/holasoymalva/pawse

PAWSE is built with:

• Electron 45 — desktop application and native camera integration.
• React 19 — interface and interactive experience.
• TypeScript — typed application architecture.
• Presage SmartSpectra Node SDK 3.4 — contactless physiological signal measurements.
• SVG + CSS — original illustrations and animations.
• Vitest — automated testing.

The cat and its environment are original vector artwork, animated without a dedicated animation framework.

Run it locally

You'll need Node.js 20+, npm, a webcam, and a SmartSpectra API key.

git clone https://github.com/holasoymalva/pawse.git cd pawse npm ci cp .env.example .env 

Add your SmartSpectra API key to .env:

SMARTSPECTRA_API_KEY=YOUR_API_KEY_HERE 

Then start PAWSE:

npm run dev 

On macOS, launching from Terminal is recommended so camera permission requests work correctly.

The project has been developed and tested on macOS with Apple Silicon. Other supported SDK platforms and packaged application builds have not yet been validated.

You can find complete installation instructions, troubleshooting, architecture notes, and testing information in the repository's README.

How It Responds to Human Signals

This is where SmartSpectra makes PAWSE possible.

The application uses two live signals:

🫁 Respiratory rate

SmartSpectra estimates the user's breathing rate in breaths per minute.

PAWSE converts this measurement into the duration of the cat's breathing animation.

For example:

These are illustrative mappings, not target breathing rates.

The animation engine smoothly adjusts its timing as new measurements arrive, avoiding abrupt movement.

An important distinction: SmartSpectra provides a respiratory rate estimate. PAWSE follows that rate; it does not claim to identify the precise beginning of each inhalation or exhalation.

💓 Heart rate

PAWSE also reads the pulse rate provided by SmartSpectra.

A soft glow on the cat's chest pulses according to the measured heart rate.

Rather than showing a clinical visualization, this turns another physiological signal into a subtle part of the character's behavior.

🐈 Personality beyond the measurements

Not every movement is tied to a biometric signal.

PAWSE also has independent ambient behaviors:

• Natural blinking and curious glances.
• Gentle head tilts.
• Occasional ear twitches.
• Tail swishes and flicks.
• Small environmental animations.

These movements give the cat personality without pretending to measure emotions.

Live signal indicators distinguish measured data from decorative animation.

Architecture

I used the SmartSpectra Node SDK inside Electron's main process rather than the React renderer.

The data flow looks like this:

Webcam ↓ SmartSpectra Node SDK ↓ Physiological metrics ↓ Signal normalization ↓ Electron IPC ↓ React experience ↓ Animation engine ↓ PAWSE 🐈 

The application requests breathing and cardiovascular metrics from SmartSpectra.

It decodes SDK metric events, validates the readings, and passes normalized signals through a small, typed IPC interface.

The renderer receives the measurements it needs to animate PAWSE, without direct access to the SDK, camera, or API key.

The experience also uses the SDK's stability and confidence information to decide when readings are suitable for the timed session.

A stable respiratory signal starts the 60-second experience. When that signal becomes unavailable or remains unstable, PAWSE pauses and communicates the situation.

The animation engine uses deterministic calculations, allowing physiological signal mapping and character behavior to be tested without a live camera.

The project also includes automated tests for session management, animation behavior, IPC, and the complete experience.

Prize Categories

I'm submitting PAWSE for both optional prize categories.

🏆 Most Creative or Delightful Use

What if a physiological signal could become a character's personality?

I didn't want to build another health dashboard with a cute illustration next to it.

I wanted the illustration to be the interface.

PAWSE turns an invisible physiological process into something playful and tangible.

Your breathing becomes the movement of a tiny cat.

Your pulse becomes a little glow.

And the experience ends with a small moment of affection.

The most delightful part is that the interaction doesn't require learning complicated controls.

You simply sit in front of your camera and breathe.

The human body becomes the controller, without the user having to think about controlling anything.

💚 Best Thoughtful Real-World Use

Many of us spend our days staring at screens, moving between tasks, notifications, and deadlines.

PAWSE is designed as a small invitation to pay attention to breathing during an ordinary day.

It's intended for anyone who wants a brief, low-pressure moment away from their usual workflow, especially people who spend long hours at a computer.

The design follows a few principles:

No additional hardware. An ordinary compatible webcam is enough.

No performance pressure. There are no breathing targets, rankings, streaks, or biometric scores.

Clear consent. Users choose when camera measurement begins.

Honest feedback. PAWSE distinguishes stable, unstable, missing, and simulated measurements.

Short interactions. The core experience lasts just 60 seconds of valid measurement.

Accessible interaction. The interface supports keyboard navigation and reduced-motion preferences.

PAWSE is not a medical application, and it makes no claims about diagnosing, monitoring, treating, or improving any medical condition.

Its purpose is simpler: make a moment of breathing awareness feel approachable and enjoyable.

Consent and Data Handling

Privacy and consent were important design considerations throughout development.

Camera consent

PAWSE never begins camera measurement automatically.

Before starting a session, the user sees an explanation of why the camera is needed and must explicitly consent.

The user can stop the session at any time.

The application releases the camera when a session stops, completes, or the application exits.

Storage and retention

PAWSE itself does not record or store camera frames, video, or physiological measurements.

Measurements are handled in application memory while a session is active.

PAWSE does not implement an account system, biometric history, or cloud database.

There is no application-level physiological data history to retain or delete.

Electron may maintain ordinary application profile data, but PAWSE does not intentionally persist biometric readings there.

Sharing and SDK network activity

PAWSE does not implement its own service for uploading or sharing biometric measurements.

However, SmartSpectra communicates with Presage services for SDK-related functionality, including authentication and potentially device provisioning and model delivery.

The application sets enableTelemetry: false, disabling the SDK's optional telemetry feature.

This does not mean that the SDK operates completely offline or makes no network connections.

According to SmartSpectra's documentation, physiological processing is performed on-device and raw camera imagery is not transmitted. I have not independently verified the contents of the SDK's encrypted network traffic, so I do not claim that no information leaves the device.

For more details, see the repository's privacy documentation and SmartSpectra's documentation.

API keys

SmartSpectra credentials are loaded from a local, Git-ignored .env file into the Electron main process.

The key is not exposed to the React renderer or the application's IPC interface.

Users running PAWSE from source must provide their own SmartSpectra API key.

Optional AI services

PAWSE does not use an AI chatbot, external generative AI inference service, or LLM to analyze user camera data during its operation.

The cat's movements are produced by deterministic animation logic and the measured physiological signals.

Claude Code was used as a development assistant, but it is not part of PAWSE's runtime experience.

Responsible use

PAWSE is intended exclusively for general wellness and informational purposes.

It does not diagnose or treat medical conditions, make medical decisions, perform covert monitoring, or infer emotional or mental states.

The cat's expressions reflect its own animated behavior and the application's connection state, not a medical or psychological assessment of the user.

Agent Session

I built PAWSE with the assistance of Claude Code, using an iterative development process covering the SmartSpectra integration, desktop architecture, signal processing, animation engine, user experience, testing, and stabilization.

[Optional: Add a public, curated Claude Code agent session here.]

The development process included automated tests, simulated physiological measurements for visual iteration, and manual testing with a real webcam.

The simulation environment was particularly useful because it allowed me to test the cat's behavior without repeatedly consuming SmartSpectra SDK credits.

Any shared agent transcript will be reviewed to remove API keys and sensitive information before publication.

Final Thoughts

I started this project wondering whether a webcam and a physiological sensing SDK could create something more personal than a dashboard.

The result was a tiny black cat with green eyes, a moving belly, a restless tail, and a little glowing heart.

A creature that doesn't ask you to reach a goal.

Doesn't care about your productivity.

And doesn't need you to improve your numbers.

It just breathes with you.

That might be my favorite part of PAWSE.

Thanks to Presage and the DEV Community for creating a challenge that encouraged me to explore a different side of human-sensing technology.

If you'd like to explore the code, run PAWSE, or contribute ideas, the project is available on GitHub:

🐈 https://github.com/holasoymalva/pawse

Made with care, and with a little bit of breathing. 💚