Soloist: A Generative Self-Portrait Engine That Evolves With Data

The plan is to build a system that takes in data from a single user (me) every day – heart rate, steps, sleep, weather, location, calendar mood entries, social media sentiment – and uses that to parameterize a generative portrait. The portrait would be a colorful abstract face or figure that changes over time. The tech stack would include a Raspberry Pi with sensors, a web app for manual inputs, and a p5.js canvas for rendering. The architecture is a pipeline: daily data collection via APIs and manual entry, stored in a local SQLite database, processed by a Python script that maps data to visual parameters (color palette, stroke weight, symmetry, etc.), then renders the image. The goal is to have a physical e-ink display in the home that updates daily with a new portrait. Since it's a team of one, everything must be automated but manageable. The project never got built because the creator moved to a new city and lost the prototype hardware.

As a solo creator, I wanted to explore how a single person's data could create a meaningful and evolving artwork that reflects subtle daily changes, but I found existing tools too generic or required multiple contributors. This scratches an itch for a deeply personal, slow-changing art piece.

• Create a daily generative portrait that uses only my own data.
• Build a fully automated pipeline from data ingestion to rendering.
• Display on a low-power e-ink screen in my living room.
• Keep the code open-source so others can fork for themselves.
• Achieve a visually interesting variety without manual intervention.

• Not a social or collaborative project.
• Not trying to visualize data in a literal way (e.g., no bar charts).
• Not aiming for high accuracy or scientific rigor.
• Not selling prints or monetizing.

• Raspberry Pi 4 with PiJuice hat for battery.
• Pulse sensor (heart rate), GPS module (location), and local weather API.
• Python scripts for data collection and processing.
• SQLite database.
• p5.js for generative rendering (deployed as a local server).
• Waveshare e-ink display (7.5-inch, 800x480).
• Manual mood input via a simple web form.

Data flows: 1) Every hour, a cron job runs Python scripts to collect heart rate (via pulse sensor GPIO), location (GPS), and fetch weather from OpenWeatherMap. 2) At bedtime, a web form prompts for mood (1-5 scale) and daily highlights. 3) At 6 AM, a script aggregates the past 24h data into features: avg heart rate, max/min, sleep duration (from sleep tracking), steps (from phone via manual sync), weather conditions, mood average. 4) Then a generative algorithm maps each feature to visual parameters: e.g., heart rate range maps to color hue shift, sleep duration maps to symmetry axis, mood maps to stroke chaos. 5) The p5.js sketch renders a self-portrait based on these parameters. 6) The final image is converted to grayscale for e-ink and displayed via screen update. The algorithm also includes stochastic elements to ensure no two days are identical even if data is similar.

• Sensor data unreliability (heart rate spikes, GPS drift).
• Manual data entry might be forgotten.
• E-ink screen ghosting or low contrast.
• Burnout from maintaining a daily routine.

• Should the portrait be a face or an abstract geometric representation? How to make it feel like a self-portrait without being literal?
• What if data is missing for a day? Should it interpolate or leave blank?
• How to handle privacy if open-sourcing? The actual data wouldn't be shared, only the code.

I started building the sensor hardware but moved to a new apartment and the project got deprioritized. The idea remains as a detailed plan in my notebook. Life got busy.

This project is a meditation on solitude and self-awareness. The solo aspect is the whole point: it's a conversation between one person and their data.