In the spring of 2019, I saw a ring of light hovering above Kichijoji Station in Tokyo. I still cannot explain what physically happened, but from that day on, a quiet conviction settled inside me: visual expression is a vehicle that carries meaning. Composition, negative space, and color are no longer ornaments to me — they are a kind of language.
Holding that sense, I have spent the last few weeks asking Rork to prototype an art-focused app. I am Masaki Hirokawa, an artist and creator. I move between two practices: 17 international art awards on the gallery side, and over 50 million downloads of indie apps I have shipped since 2014. From that dual position, I want to give you an honest reading of what Rork did well and what it did not, when asked to handle the kind of detail an art app requires.
What I Tried to Build — A Prayer-Themed Gallery App
The subject matter came directly from my art practice: "exploring collective psyche, the structure of the cognitive world, and root consciousness against the backdrop of Japanese prayer." I wanted to fold three experiences into a single app.
- A work gallery (vertical scroll, pinch-to-zoom, layouts that lean on negative space)
- Voice narration per work (my own voice describing the background of each piece, intended to embed audio from stand.fm)
- A "Prayer Mode" — color temperature and the ratio of empty space shifting silently with the time of day and the weather
The third item is the hardest. If a UI framework lacks depth, this kind of quiet transition cannot be expressed at all. Pixel-level negative space and subtle modulation of color temperature are non-negotiable for an art app. The whole experiment turned on whether Rork could meet that demand.
An Honest Read of the First 30-Minute Output
I handed Rork a bullet-point prompt describing those three experiences and waited. About thirty minutes later, the first version arrived, and the structural quality was higher than I expected.
- A complete React Native (Expo) project, ready to run
- A FlatList-based gallery with a pinch-zoom library wired in
- A stub narration screen with working play, pause, and seek
- A theme-switching scaffold for "Prayer Mode" routed through Context API
From the perspective of someone who has been writing indie apps for twelve years, that is a respectable starting point. But here is where the real test began. Rork's output was acceptable as a skeleton, yet the moment I went deeper into the kind of detail an artwork demands, the spaces left for human craft became visible.
// Rork's initial ThemeProvider — too shallow for art-grade work as is
const ThemeContext = createContext({ mode: "day", setMode: (_: string) => {} });
export function ThemeProvider({ children }: { children: ReactNode }) {
const [mode, setMode] = useState<"day" | "dusk" | "night">("day");
// ❌ Color temperature snaps between only three steps
const palette = {
day: { bg: "#FFFFFF", fg: "#111111" },
dusk: { bg: "#F2E8D5", fg: "#3A2B1B" },
night:{ bg: "#0E0F14", fg: "#E8E4D8" },
}[mode];
return (
<ThemeContext.Provider value={{ mode, setMode }}>
<View style={{ flex: 1, backgroundColor: palette.bg }}>{children}</View>
</ThemeContext.Provider>
);
}What I wanted was a continuous, almost imperceptible drift of color temperature throughout the day. A three-step snap is not a brushstroke; it is a switch. Replacing this layer was the part of the conversation with Rork that took the most time.
How Far Can Art Context Travel Through a Prompt?
My first prompt only said "Prayer Mode," so Rork's safe interpretation — three discrete states — was almost predictable. On the second pass, I tried to translate my own internal language as concretely as I could.
"Prayer Mode" interpolates color temperature, saturation, and the ratio of negative space continuously, derived from time and weather. It is not a snap transition. The change is silent, refreshing every four minutes. Saturation is intentionally raised in the thirty minutes around sunset, and between 0 and 3 a.m., negative space expands to twenty percent of the screen.
When I gave Rork that level of specificity, it returned interpolation logic. Color temperature became a requestAnimationFrame-driven HSL interpolation, and the empty-space ratio became a useEffect that adjusts padding to the hour.
// After: continuous color-temperature interpolation by time of day
import { useEffect, useState } from "react";
function interpolateHSL(t: number) {
// 0h = deep indigo / 6h = morning haze / 12h = near-white
// 18h = amber / 24h = back to deep indigo
const phases = [
{ h: 220, s: 30, l: 8 },
{ h: 30, s: 25, l: 92 },
{ h: 0, s: 0, l: 98 },
{ h: 28, s: 60, l: 70 },
{ h: 220, s: 30, l: 8 },
];
const idx = Math.floor(t / 6);
const local = (t % 6) / 6;
const a = phases[idx], b = phases[idx + 1];
const h = a.h + (b.h - a.h) * local;
const s = a.s + (b.s - a.s) * local;
const l = a.l + (b.l - a.l) * local;
return `hsl(${h}, ${s}%, ${l}%)`;
}
export function usePrayerPalette() {
const [bg, setBg] = useState(interpolateHSL(new Date().getHours()));
useEffect(() => {
const id = setInterval(() => {
const now = new Date();
const t = now.getHours() + now.getMinutes() / 60;
setBg(interpolateHSL(t));
}, 4 * 60 * 1000); // refresh every four minutes
return () => clearInterval(id);
}, []);
return bg;
}Here I noticed the most important finding of the whole experiment. Rork accepts artistic vocabulary only loosely, but it is remarkably faithful to instructions written with numbers, durations, or ratios. If the artist is willing to translate their own sensibility into "math, time intervals, and percentages," Rork follows further than I expected. Conversely, prompts built on adjectives alone — "more negative space," "more prayerful" — almost always settled into a safe, average reading.
A 50-Million-Download Lens — Will This Survive in the Real World?
Let me switch lenses. From the angle of running indie apps for twelve years, with cumulative downloads above fifty million, an art app cannot be judged by visuals alone. It has to run every day, pass review, and stay healthy on real users' devices.
- Cold start: about 2.6 seconds out of the box. After trimming the FlatList initial render count and swapping to
expo-image, it dropped to 1.4 seconds. - Memory pressure: with a hundred high-resolution works on screen, the initial implementation crashed on an iPhone SE (2nd gen). Replacing the list with a
recyclerlistview-style component stabilized it. - Accessibility: VoiceOver was silent during pinch zoom at first. I had to attach
accessibilityLabelandaccessibilityHintto each work. - Store review: shipping voice narration meant adding a privacy manifest entry and a recording-purpose declaration.
None of these are problems Rork resolves in a single shot. They are the same handwork I have done countless times across my wallpaper apps and healing-themed apps. During the period when AdMob revenue was crossing one and a half million yen a month, I learned this the hard way: an app that survives in the store cannot be built from "the first structure" alone — it has to be carried by the accumulation of small daily fixes. Rork shortened the runway by perhaps three weeks. It did not carry me to the gate.
For wider context, I have laid out related thinking in A Realistic Comparison of Rork-Centered Monetization and The Rork App Development Guide for Artists and Creators. They sit underneath this review.
Five Situations Where Rork Helps an Art App, and Where It Does Not
After three weeks of prototyping, the seam between "let Rork handle this" and "an artist must hold this" became clearer. For art-focused apps specifically, here is the line I draw.
- ✅ The first 24 hours of structure: navigation, screen routing, and state management are fine to delegate to Rork.
- ✅ Standard UI parts: buttons, forms, sheets, lists — Rork handles the foundation cleanly.
- ✅ Accessibility scaffolding: labeling and contrast ratios are reasonable to ask Rork for as a first pass.
- ❌ Final adjustments to negative space, color temperature, and typography: this belongs to the artist. Even when prompted with numbers, the last verification has to happen by hand.
- ❌ Selection of static assets: photographs, voices, fonts — these belong to the artist's perception. They are not for AI to choose.
In 1997, when I first encountered the internet at sixteen, I felt the boundary between technology and expression dissolving. Rork sits in the same lineage. It is convenient, and useful. But if convenience is allowed to take over, the work begins to drift toward "something anyone could have made." Delegate generously where it helps, and hold the parts that draw the artist's outline. Just being aware of that distinction reshapes the relationship with Rork entirely.
Start by Naming One Thing in Your Work That Can Be Spoken in Numbers
If you are an artist, or an indie developer who wants to ship an art-focused app, here is the single first step I would suggest. Pick one element of your own practice and write down the part that can be spoken in numbers. Color temperature in degrees Kelvin. Negative space as a percentage of the screen. Rhythm in seconds. Just one line. The moment that line exists, Rork begins to respond beyond what you expected.
Thank you for reading this far. What I saw in this experiment is still settling in me, and I would be glad to keep learning alongside you.