The network for creativity
Join 1.25M professional creatives like you
Connect with clients, get discovered, and run your business 100% commission-free
Creatives on Contra have earned over $150M and we are just getting started
Back to feedPost
UNLIT: Everything You Light Looks Back
UNLIT is a tiny horror game that lives entirely inside one Rive file. It opens with a story told inside Rive: on the night of the storm a demon took the woman he loves, and her trail ends at the door of a house whose old master, the necromancer Corvin Ashgrave, never left. Every room hides a relic; together they can break the demon's hold. This room is the first chapter, and the house promises more.
You stand in a Victorian parlor with a dying torch. Eight relics are hidden in the dark, and so is something else. Eyes open in the doorway, the cracked mirror, the cold fireplace and the window. Stare them down until they look away, or they come for the screen.
No two games are the same: the relics are dealt to new hiding places each time, two of them are mimics that breathe and bite, a faceless walker crosses the room and steals a relic if you light it, writing on the walls only shows in the hot core of your beam, and when lightning strikes the window, the necromancer is sometimes standing outside. Hold to flare the torch and drive everything back, at the cost of battery. Sound on, headphones if you dare: doors slam on your left, footsteps pass behind you, and voices in the dark tell you, from one side or the other, that they can see you.
How it is built (Rive CLI + GPU Canvas, both):
• Rive CLI: the whole scene is RML written with Claude Code as my coding agent. Five artboards (the screen, the room, the overlay, the writings, the prologue), a Game view model, state machines for the screens, the five jump-scare lunges and the dying battery, and a data-bound HUD whose values ease in through converter chains.
• GPU Canvas: a Luau layout script draws the lit room and the writings into offscreen canvases every frame and hands them to a WGSL shader that decides what you are allowed to see: a warm torch cone, cold moonlight, fog that only shows inside the beam, UV-like ink, a flare bloom, a shadow rushing past, film grain, a heartbeat vignette and a possessed-screen glitch with chromatic tearing.
• The prologue, in Rive: six painted panels on one timeline (slow Ken Burns drift, lightning, looping rain, letterbox, captions, a handwritten inscription on the scroll), written as RML. The Luau script scrubs that timeline with setTime() and fires the narration, thunder and rain on the same clock, so picture and voice can never drift apart. One click skips it.
• Scripting: the same script directs the haunting (spawns, stare-downs, mimics, the walker, battery, both endings), places the relics, draws the eyes that track your torch, and plays the sound. Rive has no audio panning, so positional sound is baked into stereo files.
• Data Binding + State Machines: the script only writes view model values and fires triggers. The markup reacts on its own.
• A calm title screen: the rules wait behind a "how to play" panel, assist mode is one tap away, a pause menu (Esc or P) lets you restart or go back to the title, and the end screens close with a threat about the rooms still to come.
• Responsive by design: it adapts to any window and pixel density, and plays on a phone in landscape with the torch riding above your finger so it never hides what it lights.
• Accessible by design: fear is for everyone. An assist mode on the title screen gives a brighter, wider torch, a dimly visible room, high-contrast outlines around relics, a sonar-like ping that quickens as you near one, bigger eyes, and no strobing, shaking or red flashes for photosensitive players (the lightning in the prologue and at the window turns into a slow glow). The story is always captioned, and in assist mode so are the voices in the dark, with the side they come from. The one tell carried by colour (a mimic's red glint) is also a different shape and a breathing motion, so it reads without colour vision.
• Human touch (Rive Editor): the title hides a blood red that only your torch can reveal, the same way it uncovers the writing on the walls. I designed it by hand in the Editor: dark grey letters with a blood red hidden inside them that the light burns through, a soft halo, and a stuttering dying-bulb flicker keyed frame by frame.
Assets: room, creatures, relics and the prologue's panels generated with Higgsfield and art-directed into one gothic storybook palette; the English narration is Higgsfield text to speech. Creature screams come from Higgsfield video audio; ambience, heartbeat, whispers and positional effects are synthesized in code.
Features used: Rive CLI, GPU Canvas (WGSL), Scripting (Luau), Data Binding, State Machines.
The network for creativity
Join 1.25M professional creatives like you
Connect with clients, get discovered, and run your business 100% commission-free
Creatives on Contra have earned over $150M and we are just getting started
Related posts
Take a vampire, a grim reaper and a bat for a midnight ride through a haunted town. Hold to boost over broken track, brake before the big hills, and grab candy to refill your boost. Push your luck too far and your passengers end up splattered across the screen.
Cute!!
Night Post: Letters Find Home
A friendly Halloween puzzle in an original 3D paper village inspired by an Irish street. A small ghost postman has three letters to deliver. Turn the road tiles to connect the postbox to the numbered front doors; every successful delivery reveals a waiting neighbour and warms another home.
Play by tapping the tiles or using keys 1–9. Send a letter only when the road is connected. H gives one useful hint; replay, sound and calm-motion controls are included. The courier follows the visible road curves at a constant travel speed, turns smoothly, and returns along the same route. Roads lock during delivery.
Built with Rive CLI, GPU Canvas, native Rive state machines and data binding. The original procedural village has depth-tested mesh houses, roof slopes, window reveals, paper grain, a letter handoff and antialiasing where supported. Native state transitions animate the delivery stamps. The 57-second walkthrough shows actual public-browser gameplay and real RML, WGSL and Luau source excerpts.
My contribution: I chose the Irish setting and the feeling of finding home, and provided critical design review of geometry and motion. The original mesh artwork, code and animation were developed with AI assistance. No manual Rive Editor work or personal voice recording is claimed. Geometry and synthesized chimes are original; no competitor assets are reused.
#rivehalloweenchallenge
🎃 Trick or Room
A cute-spooky puzzle game where every room you survive lets you build one that haunts someone else's night, and the monsters you design roam other players' rooms.
▶ Play it (phone or desktop): https://trickorroom.canvastools.nl
⭐ Judges, short on time? https://trickorroom.canvastools.nl/?judge opens everything: the whole manor, Create's tools, every costume and endless candy, on saves of its own.
You're Tuck, a trick-or-treater in a bedsheet, sneaking through a haunted manor. Every room is a small turn-based puzzle: monsters move only when you move. Gloop patrols, Mumbles the mummy chases, Flit the bat bounces off the walls and Echo copies your every step. Push pumpkins onto plates, flip levers, lure Mumbles behind a wall, grab the candy and reach the door, in par if you can.
Clearing a room is the reward: its pieces unlock in your room builder. Build a room, prove it can be cleared, publish it, and the manor slips it into other players' nights. Their treats fill your candy jar while you're away, raise your haunter rank and buy Tuck costumes.
Play on and Create opens up: the Object Workshop for furniture of your own, then the ultimate reward, the Monster Lab. Pick a body, a face, extras, colours, a pattern and a move, and watch it act out its behaviour. Let it roam, and it turns up as a guest in other players' rooms.
On the title, the two O's of ROOM are my own jack-o'-lantern, rigged and animated by hand in the Rive Editor: the Watcher turns his head after your pointer in semi-3D, and the Moody One shows how he feels. Tap him and he laughs, fuss over his brother and he gets jealous, leave and he sulks, wait and he dozes off.
Also: Endless Night (how many rooms before dawn?), a Hall of Fame, invites, and the whole game in English and Dutch.
Built in about 23 hours of work, in under three days: from the first prompt on Thursday afternoon to this entry on Sunday morning.
Along the way I also worked out a variant for Tilburg Law School (Tilburg University): the same game as a way to learn, with its own cast of students. It isn't built yet, but it shows where this can go: Trick or Room as a template that can be re-themed and reused.
How it uses Rive
• Rive CLI: the whole game is plain text in a repo (RML markup, Luau scripts and a WGSL shader). Every change is checked from the terminal (rive --verify, rive inspect, rive --test with 175 Luau tests, and 160 headless screenshots in English and Dutch), built with a coding agent as a pair programmer. CI signs every push with rive --publish and deploys it; every branch gets its own test link for phone tests.
• Luau: the rules engine (pure and tested) and a solver that proves every manor room can be cleared; tap-to-walk pathfinding; the stage that draws each room from character and prop artboard instances; the builder; Endless Night; the Lab's live demo running the real rules; players' monsters put together at runtime from 370 rendered parts; the brain behind the title's Jacks.
• Data binding: one Game view model is the contract between the .riv and the web page: progress, candy, community rooms, plays, clears and treats, roaming monsters, the Hall of Fame, invites and the language. Every text on screen is bound, which is how the EN/NL switch works.
• State machines: every character has layers for mood, facing, blink and costume; the screens are a state machine; cards pop in, wax seals stamp, jelly buttons squash and wobble; the Moody One's six faces.
• GPU Canvas (WGSL): the night itself. Tuck's lantern with soft shadows traced through the room's walls and furniture, candle tables, a moonbeam, the BOO! shock (a chromatic ring and a screen shake), iris transitions, rays and sparkles on a clear, Echo's afterimages, the title's fog and lightning, the dawn.
• Art: soft 3D clay, modelled and rendered in Blender by script, rigged in parts and animated in Rive; a UI kit of 3D panels and jelly buttons N-sliced in Rive.
The human touch
• The concept and the reward loop are mine: rooms that haunt other players' nights, the Monster Lab as the ultimate reward, players' monsters roaming other players' rooms.
• Decided on a real phone: isometric and landscape versions were built, tested and rejected; the straight view, tilted 52°, was picked from three; the Lab was redone when its chips proved too small.
• Art direction by hand: the UI style (a mix of three proposals), the candy corn, the hero's name, and my own jack-o'-lantern in the logo.
• Hand-animated in the Rive Editor: the Jacks' rig (ribs on bones, a joystick for the semi-3D turn), the Moody One's faces, the gaze. The film's Human Touch part shows the recordings.
• Rooms designed by hand, then checked against a solver that plays the real rules.
Features used: the Rive CLI and GPU Canvas, plus Luau scripting, data binding and state machines.
@rive_app #rivehalloweenchallenge
This is next level Math! Love the loop — survive a room to build a room that haunts others. The Monster Lab idea is brilliant. And those two O's in the title — I noticed the Watcher follows the pointer in semi-3D, such a nice Rive touch. Played 3 rooms, Mumbles got me twice