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.
- Sole developer
- Solo
- Oct – Nov 2026
- Android phones and tablets
- Expo, React Native, TypeScript, Skia, Reanimated, expo-sqlite, Supabase
- In development · Google Play closed testing
- Private repository
Long Exposure3 photos · 3 slides
Scatter10 photos · 3 slides
Admit One3 photos
Dump Day9 photos · 5 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
- Expo SDK 58 · React Native 0.88 · React 19 · strict TypeScript · expo-router
- React Native Skia · Reanimated 4 · Gesture Handler 3
- expo-sqlite on the device · Supabase (Postgres, Auth, Storage) for templates
- EAS Build · GitHub Actions: lint, typecheck, tests, build · Google Play closed testing
- 364 test cases in 34 files
System architecture
Everything Chroniva draws comes from one template definition, through one renderer.
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
StripComposition
Skia · draws any template at any size
Photo filters
colour matrix and film grain
One renderer to Outputs: the same element tree
Live preview
on screen, while editing
Export
drawAsImage at 2× · JPEG, quality 92
Creation
files plus a frozen copy of the template
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.
/**
* 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:
/**
* 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
One renderer for preview and export
- A single Skia composition, used for the live preview and the exported file.
- Separate preview components and a separate export pipeline.
- Two implementations of the same picture drift apart; one can’t.
- The preview carries the full renderer’s cost, so performance work happens in one place that has to serve both.
The database is the boundary
- Row-level security, a validation trigger, immutable published versions, and role checks in every publishing function.
- Relying on the admin screens being hidden in the app.
- Hiding a screen is a convenience. Anyone can call the API directly, so every write is checked where the data lives.
- More SQL to write and test than a client-side check would need.
Freeze the template inside every creation
- Store a copy of the template with each saved strip.
- Referencing the template by id.
- Templates get edited and republished. A strip someone made last month should still look the way it did when they made it.
- 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.
Classic Strip4 photos
Receipt4 photos
Photo Dump9 photos
Contact Sheet 358 photos
Admit One3 photos
Long Exposure3 photos · 3 slides
Scatter10 photos · 3 slides
Twenty20 photos · 5 slides
Dump Day9 photos · 5 slides