Harry De Torres

Solo project · Oct – Nov 2026

Chroniva

A monochrome photo booth for Android phones and tablets.

It shoots a sequence, frames it in a template and exports a real composite strip. A carousel studio splits one wide design into Instagram slides that join back into a single picture.

Role
Sole developer
Team
Solo
Timeline
Oct – Nov 2026
Platform
Android phones and tablets
Stack
Expo, React Native, TypeScript, Skia, Reanimated, expo-sqlite, Supabase
Status
In development · Google Play closed testing
Source
Private repository
  • 123

    Long Exposure3 photos · 3 slides

  • 12345678910

    Scatter10 photos · 3 slides

  • 123

    Admit One3 photos

  • 123456789

    Dump Day9 photos · 5 slides

Four bundled templates, drawn from the app’s template data. Dashed lines are the cuts between carousel slides.

Introduction

Chroniva is a monochrome photo booth for Android phones and tablets. It shoots a sequence of photos, frames them in a template and exports a real composite strip. Its carousel templates go a step further: one wide design is split into Instagram slides that join back into a single picture as you swipe.

I built the first version on my own in a week, from 31 October to 7 November 2026. It’s in development now, and releases go to Google Play closed testing through an automated Android pipeline.

Problem and motivation

A photo booth app is only as good as its templates, and templates multiply. If every layout is its own screen, each new design means new code and a new release, and the preview on screen and the exported file become two implementations of the same picture that slowly drift apart.

Carousels add two harder problems. A photo that crosses the cut between two slides has to continue exactly on the next one. And the export has to work on phones whose GPUs limit how large a single image can be, when a five-slide carousel at export size is 5,400 pixels wide.

So the goal was templates as data, one renderer for everything, and an export that is the preview, only bigger.

Users and context

Chroniva is for anyone who wants booth-style strips from their own phone, at a party, with friends or for a post. There’s no account and no sign-in for them. The app reads published templates, and everything they make stays on the device.

The only accounts are for administrators, who design and publish templates in a builder inside the app. That builder is compiled only into development builds; the store builds don’t contain it.

Role and contributions

Solo project: design, the app, the template builder, the Supabase backend and the release pipeline.

I worked with AI coding assistants as pair programmers. The architecture, the template model and the security boundary are my decisions, and I reviewed and tested what the assistants wrote.

Technologies

App
Expo SDK 58 · React Native 0.88 · React 19 · strict TypeScript · expo-router
Rendering
React Native Skia · Reanimated 4 · Gesture Handler 3
Storage
expo-sqlite on the device · Supabase (Postgres, Auth, Storage) for templates
Release
EAS Build · GitHub Actions: lint, typecheck, tests, build · Google Play closed testing
Tests
364 test cases in 34 files

System architecture

Everything Chroniva draws comes from one template definition, through one renderer.

Template data

  • Template definition

    schemaVersion 1 · geometry 0–1

  • Published versions

    immutable, served from Supabase

  • Bundled set

    101 templates, 42 of them carousels

Template data to One renderer: one definition

One renderer

  • StripComposition

    Skia · draws any template at any size

  • Photo filters

    colour matrix and film grain

One renderer to Outputs: the same element tree

Outputs

  • Live preview

    on screen, while editing

  • Export

    drawAsImage at 2× · JPEG, quality 92

  • Creation

    files plus a frozen copy of the template

Fig. 1The live preview and the exported file are the same composition, drawn at different sizes.

Templates are administered in Supabase and versioned. Users never write to the backend: they read published templates, and their photos, strips and history live in a local SQLite database and the app’s documents folder.

Key implementations

Geometry that doesn’t care about size

The whole system rests on one rule in the template model: every position and size is a fraction of the canvas.

src/types/template.ts · TemplateDefinitionSimplified
/**
 * Template domain model. Templates are administrator-managed, versioned, and
 * data-driven: the rendering engine interprets a TemplateDefinition, so no
 * template is ever hardcoded as a screen.
 *
 * All element geometry is normalized (0–1) against the canvas so a definition
 * renders identically at any preview or export size. Lengths that are not
 * positions (font size, border width, corner radius) are fractions of the
 * canvas width.
 */
export interface TemplateDefinition {
  schemaVersion: 1;
  canvas: TemplateCanvas;
  /** Paint order: first element is drawn first. */
  elements: TemplateElement[];
}

export type TemplateElement = PhotoFrameElement | TextElement | DecorationElement | ImageElement;

That rule is why the preview and a 2× export are the same picture. It’s also what made the template drawings on this site possible: they’re drawn directly from the app’s template data.

Exporting one slide at a time

A carousel isn’t rendered as one huge image and then cut up. Each slide is the full composition, shifted so that slide sits in the frame, and drawn at slide size:

src/services/template-rendering/export.ts · renderSlidesToFilesSimplified
/**
 * Renders a carousel one slide at a time: each slide is the same StripComposition, shifted so that
 * slide sits in the frame, so elements that cross a cut continue exactly on the next slide. Drawing
 * slide-sized images keeps every surface well under the GPU's texture limit, however many slides.
 */
const size = slideExportSize(definition, scale);
const step = slideWidth(definition) * scale;
for (const index of indexes) {
  onSlide?.(index, total);
  // Give the progress label a chance to paint before the render holds the JS thread.
  if (out.length > 0) await new Promise((resolve) => setTimeout(resolve, 0));
  const element = createElement(
    Group,
    { transform: [{ translateX: -index * step }] },
    createElement(StripComposition, {
      definition,
      width: definition.canvas.width * scale,
      photos,
      assets,
      fonts,
      edits,
      date,
    }),
  );
  const image = await drawAsImage(element, size);
  if (!image) throw new Error(`Slide ${index + 1} could not be rendered`);
  const file = fileFor(index);
  await encodeTo(image, file, quality);
  out.push({ uri: file.uri, ...size });
}

Because every slide is cut from the same composition, a photo that crosses a cut continues on the next slide to the pixel, and no surface is ever larger than one slide.

A builder that snaps like a design tool

Administrators design templates in a canvas editor inside the app. Moving or resizing an element snaps to the canvas edges and centre, to other elements’ edges and centres, and to equal gaps between neighbours. On carousels, slide cuts and slide centres become targets too. Alignment with objects and the canvas wins over the grid, and the grid only applies on an axis that found nothing else.

Saved strips never change

Saving a strip copies the source photos into the app’s documents folder, renders the final JPEG (one per slide for a carousel), and records the creation with a frozen copy of its template. If any step fails, all of it is rolled back. Published template versions are immutable as well, so editing a template later can’t change a strip someone already made.

Challenges

Big images, small GPUs

Exporting at 2× makes a five-slide carousel 5,400 by 1,350 pixels, and how large a texture a phone’s GPU can hold varies from phone to phone. Rendering slide by slide keeps every surface the size of one slide, however many slides a template has.

Keeping the app responsive during export

Skia rendering holds the JavaScript thread while it draws. The export yields between slides so the progress label can update, instead of the screen freezing until the last slide is done.

A template that is wrong in a way the builder missed

The builder checks templates as you design them, but it isn’t the only line of defence. A database trigger validates a template on any path to published, so a broken template can’t reach users even if a check in the app misses something.

Decisions and trade-offs

Decision

One renderer for preview and export

Chose
A single Skia composition, used for the live preview and the exported file.
Over
Separate preview components and a separate export pipeline.
Because
Two implementations of the same picture drift apart; one can’t.
Cost
The preview carries the full renderer’s cost, so performance work happens in one place that has to serve both.

Decision

The database is the boundary

Chose
Row-level security, a validation trigger, immutable published versions, and role checks in every publishing function.
Over
Relying on the admin screens being hidden in the app.
Because
Hiding a screen is a convenience. Anyone can call the API directly, so every write is checked where the data lives.
Cost
More SQL to write and test than a client-side check would need.

Decision

Freeze the template inside every creation

Chose
Store a copy of the template with each saved strip.
Over
Referencing the template by id.
Because
Templates get edited and republished. A strip someone made last month should still look the way it did when they made it.
Cost
Every creation stores the template’s JSON alongside its images.

Results and validation

Chroniva is in closed testing, so there are no download or usage numbers, and I won’t estimate any. What can be counted:

bundled templates: 59 single images and 42 carousels
101
test cases across 34 test files
364
renderer shared by the live preview and every export
1

Every release passes lint, type checks, tests and a build before it’s submitted to Google Play closed testing.

Not measured yet: export times across a range of phones, crash rates, and how people actually use the templates. Closed testing is where those numbers will come from.

Lessons learned

  • Let the data model carry the design. Once geometry was normalized, previews, exports at any scale, and even the drawings on this site followed from it.
  • Design for the smallest device first. Rendering slide by slide started as a workaround for limited GPUs, and it made the export simpler on every phone.
  • Put security where it can’t be skipped. The admin screens are hidden, but the database doesn’t rely on that.

Screenshots and demonstrations

There are no device screenshots here yet; they’ll come from closed-testing builds. In the meantime, here are all nine templates in this site’s extract, drawn from the app’s own data.

  • 1234

    Classic Strip4 photos

  • 1234

    Receipt4 photos

  • 123456789

    Photo Dump9 photos

  • 12345678

    Contact Sheet 358 photos

  • 123

    Admit One3 photos

  • 123

    Long Exposure3 photos · 3 slides

  • 12345678910

    Scatter10 photos · 3 slides

  • 1234567891011121314151617181920

    Twenty20 photos · 5 slides

  • 123456789

    Dump Day9 photos · 5 slides

Fig. 2Numbered boxes are photo slots, bars are text, dots are decorations, and dashed lines are the cuts between carousel slides.

Search the site

Home
WorkCase studies and smaller projects
JournalBeyond the Build, engineering notes
AboutStory, how I work, recognition
RésuméPrintable, one page
ContactEmail and links
UpsensoA point of sale that keeps selling when the internet doesn’t.
PalayCheckA rice disease scanner that would rather say “not sure” than guess.
ChronivaA monochrome photo booth for Android phones and tablets.
Copy email addressbox.devvv@gmail.com
Switch light or dark theme
GitHubgithub.com/DTHarryyy
LinkedInHarry De Torres
X@BoxDevvv
Book a 30-minute callCalendly