cinetic v1.5.0

cinetic 1.5 builds launch films and update videos from a bank of house scenes, at launch-film pace. Each point is a big line on clean ground and then one scene of 1.5-3 s. The scenes are dealt at random from the bank and vary from film to film. Nothing moves at a constant rate. The sound effects are real recordings.

The scene bank

• assets/remotion-starter/src/scenes holds 34 house scenes, each one strong moment of 1.5-3 s and a pure function of its frame. Examples:
  • a title that decodes while its call to action flies into the line, pressed by a real pointer;
  • notifications stacking in depth, a URL scan opening a grid, a page flying in in 3D;
  • a porthole that parts the line, the mark pulling back into the lockup, a ring of pictures the camera dives through;
  • a colour flood, a glossy object among drifting shapes, a prism of light;
  • a glass dome above the clouds, the product's output on real billboards, a push into a room's screen;
  • and more.
• Every scene takes the product's own words, screens, pictures, logo and palette as props, and its meta says its length, its props, the forms it takes over and hands on, big or quiet, and its sound cues.
• Each scene's leading comment carries cinetic:house-scene, and lint-film checks it as a house device.
• Tests: house-scenes, ui-scenes, scene-tables, bank-d and bank-e check every scene against its contract and its timing table, and that its subject is on screen by frame 6.

Launch and update films cast from the bank

• launch-simple casts 8-12 scenes per film. The spine carries one element across the scene changes with varied handovers, and the lockup lives until the last frame.
• update plays one line and one scene per change, in 8-20 s for two changes. It ends with the mark pulling back and the version landing on the bar line. Every length lives in src/deal.ts LIMITS, and a plan outside them stops with an error.
• The deal is random. The seed is the film's name plus the last films' scenes, weighted toward the act's verb and toward big scenes, and away from what recent films used.
  • At least 75 % of a film's scenes come from the bank, at most one scene is the film's own, no scene plays twice, and at most two come from the last film.
  • Picking a scene by hand counts as a redraw and needs a stated reason.
• A film keeps one ground, with at most one deliberate change.
• A brand you invent never takes green. Films take the brand's palette or a designed one dealt per film.

Never linear

• Nothing moves at a constant rate. Zooms run in log space (zoomAt), arrivals on expo out, exits on expo in, and travels on expo in-out (lib/anim.ts).
• lint-film's new linear-motion error fails any linear move, fade, blur or zoom. Only a true live rate passes, with // lint-ok: <reason>.

Real sound effects

• Sound effects are real licensed recordings. scripts/audio/sfx-catalogue.json lists 84 effects in 17 kinds, auditioned and measured, all from a library whose licence allows commercial films with no credit.
• node scripts/audio/sfx.mjs picks a new set per film, downloads it with licence records (never committed) and places each effect on its cue frame. sfx.mjs refine re-picks what the mix masks.
• earshot judges the mix and no longer makes the effects. Offline, synthesized takes play and the run says so.

Gates

grid-check and forensics now fail a film for any of these:

• Timing:
  • a scene over 3 s (the film's own scenes too);
  • one subject on screen for more than 4.5 s in a row.
• Lines: a lone line under 6 % cap, in more than three chunks, or on screen for more than 1.2 s.
• Seams and grounds:
  • one seam kind used for more than 40 % of the seams;
  • a speck left alone at a scene change;
  • more than two ground changes.
• The lockup:
  • over 2.5 s, or held more than 2 s after its mark;
  • leaving before the last frame;
  • an empty last 0.3 s.
• Stillness: a still run over 0.8 s before the lockup.
• The deal: a plan that breaks the deal's rules.

Long mode

When you give a film hours, each dealt scene gets its own polish pass against its recipe numbers, with stills side by side, before the next one.

CI

Seventeen test files that had no CI step now run in one step: the spine and handover tests, the launch template tests and the scene bank tests. The sound step runs the effects tests.

Also in this release

The work first planned as 1.2 ships here too. It is built for the two films a product team makes most, the launch film and the update video. A film starts from a plain script that tells a stranger within 5 seconds what the product is and does. It shows that script one line at a time, builds the product's screens in code in a lit place with depth, shows the real marks of the products it works with, and is cut to a licensed music track with a sound cast for each action. Seven film templates give a whole film's structure to start from, and gates fail a film whose motion snaps, freezes or stops dead, or whose frame holds shapes and light with no job.

Templates and the template route

A template lays a whole film's structure over the Remotion starter: the timeline (acts on whole bars, every state change a cue, the declarations), one act per shot type with the choreography between them, the sound plan and one content file of slots. The product, the words, the brand and the direction stay yours.

• new-film.sh --template <name> scaffolds from assets/templates/<name>. Its template.json lists the files it copies and the starter acts it removes, and its pace, tempo and type family become the film's defaults (--bpm and --type override them). --format update is the same as --template update.
• Seven templates, all for Remotion:
  • update, 8–20 s: "vX is out". The name and the version on a clean ground, one line and one house scene per change, the mark pulling back into the lockup with the version.
  • ui-walkthrough, 25–40 s: the user's input becomes the output on one hidden cut, proof piles up, a claim, then the product's flow in steps and the output live.
  • capability-reel, 15–25 s: a ring of sources, one real record, a capability ticker, the claim on the accent and the end card. It also works as a launch film's close.
  • camera-teaser, 20–25 s: a dark teaser of the product's screens where the camera does the moving, with one 3D turn.
  • prompt-run, 18–20 s: a request typed and sent, the steps the product runs, the running row turning into the result.
  • social-ad, 15 s: an ad cut on the product's own pictures, every seam inside a motion.
  • type-explainer, 20–30 s: one short sentence at a time on a white page, the mark becoming the hub of the product's parts.
• references/templates.md says which template fits (say the film in one sentence), what each one lays down act by act, and the grammar every template keeps when it is retimed or moved into a dealt direction's world.
• A fresh scaffold passes tsc, grid-check and lint-film with only the placeholder markers left. Every string on screen comes from the content file, and its marker fails the lint until the product's own words and data are in.
• Acts sit on whole bars, so track.py grid puts every act line on a downbeat of the film's track, and every read still holds on a faster or slower track.
• FilmEvery renders every 4th frame of the film for a quick whole-film check while you build.

Clear copy and copy-check

The script is written first, before any picture work, so that a stranger knows within 5 seconds what the product is and does.

• The launch formula: line 1 (or 2, after one short hook) says what the product is, on screen by 3 s: "[Name] is a [plain category] for [who]." or "[Name] turns [input] into [output]." Then 3–5 lines that each say one thing it does, with a verb, while the UI shows it. Then the name and what to do. An update film opens on "[Name] [version]" and says one result a line.
• scripts/copy-check.py reads TREATMENT.md, out/cues.json, a text file or stdin. It fails a line over 7 words, a lone keyword, vague and fancy words, metaphors, slogan shapes, a line with no verb or with two claims, two lines at once, a script without the name, and a film that does not say what the product is by 3 s. It prints what a stranger reads. A line that names 2–4 of the film's real marks counts as one claim.
• One clean line on screen at a time, 2–7 words, set on one line and sized to fit. A deliberate swap of two lines is declared with swap.
• grid-check.ts gains the script rule: words a line, one line at a time, the copy rate, the text share, and copy-check on COPY.
• TREATMENT.md gains a Script block. The starter's demo, the templates' slots and the worked concepts carry scripts that pass copy-check.
• New hard bans: a film that does not say what the product is by 3 s; vague, fancy or metaphor copy and slogan shapes; keyword piles; two lines on screen at once; a line over 7 words or with two claims; letters moving one by one outside a line's own text animation.

Motion design and product UI built in code

Text animation is the main event: every line of the script arrives its own way. The product is rebuilt as live components at film size, and the camera carries the picture.

• TypeLine (fx/TypePresets) plays twenty-three one-line text animations from one spec, with one renderer that measures the real font. The confident ones for hero lines: mask, land, fly, snap, room, glide, fall, open, build and punch. Then develop, typeFocus, arc, assemble, decode, wheel, erode, cycle, echo, highlight, slice, redact and swarm. Eleven exits leave at speed and are cut on their fastest frame: cut, slide, spread, collapse, drop, drift, push, split, swarm and dive, with blur kept for a small secondary line. crisp and calm entries serve hero and body lines, a hero line never takes a soft preset (HERO_PRESETS, SOFT_PRESETS, heroPreset()), and an end card never builds letter by letter. pick.py --lines draws one text animation per line, no two alike, and its plan names the presets a hero line takes.
• Type is solid early and moves while it lands (references/motion-tokens.md): near-solid ink within 4–8 f at 60 fps, a blur of 2–6 f or one that rides a landing scale, colour rather than opacity on the newest word, and a soft reveal edge of 1.2 em at most.
• TypePush pushes the camera through a line from 1.0 to 2.2×, following the reading point. fx/TypeClaim sets the claim large on the accent, flush left. ObjectLine and InlineObject set the thing a sentence names (a mark, a glyph, a chip, a small UI piece) inside the line at cap height.
• The line system: Words and Chain make room, snap the last word, focus in and mask their edge, and Words can build a line at the pace of speech (arriveX). LineSnap, FocusWord, HueSweep, Letters, TypeFill, TypeFx, InlineGap, Brackets and Knockout join them.
• The product kit in src/kit/: a theme computed from the colour recipe, parts and panels at film size, sample products with real states, ProductMoment (the film's one full-frame product moment) and the parts of a flow (Field, Tile, Row, Pill, Chip, DataRow, Notice, Composer, CodePanel, Bubble). A <Card> with no content draws kit UI, and the lint flags it.
• UI motion: the cursor's hand and pointer, its rise, press and spin-out; a held backspace and bursts of typing (TypeOn); a feed flick and a masonry settle (Scroll); a pile and a fan of cards (Stack); a ticker (MaskList); a count that speeds up into its total (growthSteps); a card that opens at the last card's size (Resize carry); a click that swells and a pop with no spring (MicroUI); the agent's step list (StepList); a send button taking off (jLaunch); the modal push (modalPush).
• Camera and seams: camPath chains moves so a camera-led shot never holds, and camVel reads its speed; DirBlur smears along the motion without the shutter pass, and Defocus softens at fixed levels; blurBridge, irisReveal, a spin-in mark (spinInState, SpinBlur), an entrance that keeps drifting under a moving camera (expoTail), DitherBands (a dissolve through dithered rectangles), Radiate rings and floods, and counterCreep.
• Carried seams hand the next shot the object and the speed. Wipe kind="push" is a hard edge that pushes the old shot along: it enters from off-frame, settles to 0.483 of the frame in 54 f, creeps and leaves on E.buildIn over 42 f, the old shot riding 0.62 of its travel; every wipe finishes on its last frame (wipeEnd()). MatchCut opens the next shot with the object one step further along its move and settles it in 36 f, braking instead of overshooting. The flash cut smears its whip's tail and its slide's head, the door split's card peeks and then rides up through the gap with the doors' speed (doorSplitState rise), and the line inside an iris opens at 1.15× the cover speed (IRIS_CARRY). references/transitions.md asks for about two thirds of the seams carried.
• Fast seams streak. A move faster than 720 px/s at 1080p smears (SMEAR): blurRanges() and shotSpeed() (lib/camera-moves.ts) and fastRanges() (lib/handoff.ts) give the frames to declare as camera blur, so a crisp film still renders its whips with the shutter, and smearEdge() streaks a travelling hard edge. FlashCut and the push-wipe draw their streak with DirBlur (smear: 'draw') or declare it ('shutter').
• More primitives for the device book: camera and seams (Rush, Flip, Orbit, Implode, Slices, Glint, Flight, Gather), light, glass and colour (Glow, Glass, Spectral, Gradients, GradientMap, Grades, Fringe, BorderBleed, Streak), texture (Textures, Ascii, DotMatrix, GlyphField, Cascade, Pixel, Stepped, Grids), UI and data (MicroUI, Loaders, Charts, Meter, Conveyor, Reels, Resize, Seed, Trace), marks (Markers, Corners, Echoes, PenStroke, Flashes) and shape (MorphPath). The brand's Mark splits a supplied SVG into parts, and Wordmark assembles and locks it up.
• The house end card (Lockup) is frontal and centred, built in one gesture, and never draws the name over the mark.
• The motion core in 1.2 names: curves by role (E.snapOut, E.glideOut, E.liftOut, E.stdInOut, E.buildIn, E.whipBuild and more), one spring class per film (SPR.landing and its kin) and the house tables in references/motion-tokens.md. The 1.1 names keep their shapes and lint as deprecated. track(), trackLinear() and curveOf() turn keyed values or progress samples into a move.
• The film context (useFilm()): every primitive runs at the film's fps and frame size. The HyperFrames starter's motion.js mirrors the motion core.
• Declarations in timeline.ts: LOOK, SEAMS, STEPPED, FLASHES, CAMERA_BLUR, COLOUR, END, REVEAL, SPRING_CLASS, STRUCTURAL and SALIENCE. Every primitive exports declares(), export-cues.ts writes them into out/cues.json, and the checks treat a declared step, flash or seam as craft while still failing an undeclared pop.

Type families, faces and font matching

• Inter at its display cut is the default face. Both starters load it from its optical-size file, so every size takes the display cut, and the calm and bold numbers land on the house letter fit in it.
• Faces are chosen by look from a set in scripts/faces.json: free faces (SIL OFL 1.1, from @fontsource-variable) in five looks. Neutral: Inter, the default, with Geist and Inter Tight. Tight: Inter Tight, with Public Sans. Geometric: DM Sans, with Google Sans Flex and Urbanist. Friendly: Manrope, with Plus Jakarta Sans and DM Sans. Technical: Geist with Geist Mono, and JetBrains Mono. Each face carries the CSS it is vendored from (its optical-size file where it has one) and its weight and tracking offsets against the house numbers, measured against Inter. references/copy-and-type.md §6 maps a brand's personality to a look.
• add-font.mjs --list prints the set; add-font.mjs vendors a set face with its offsets and warns on a face outside it. deck.py deals the face from the type option's look (the look's main face twice as likely as each alternate) and prints how to get it.
• Type roles come in two families, one per film (TYPE_FAMILY in tokens.ts). Calm, the default: line 84, display 160, hero 200 and giant 640 px at 1080p, in regular weights at the face's own letter fit. Bold: line 120, display 200, hero 240 and giant 900, semibold, with tracking that tightens with size. Both have ui 40 and caption 46, and nothing under 36 px is held in focus.
• scripts/type-family.mjs calm|bold writes a family's six roles and face weights into src/brand/tokens.ts, and --check says whether they are in step. new-film.sh --type and a template's type_family run it.
• scripts/font-match.mjs finds the free face closest to a target (a crop of a frame, a brand face that cannot ship, or numbers) by ink width, x-height and stems measured in Remotion's own Chrome, with the weight, size and tracking that match. It ranks the face set's pool by default (--pool mono|serif for the others). --sheet draws the target over every candidate; --fetch packs candidates from npm into a temp folder.
• add-font.mjs --add <key> vendors the product's own faces, such as a UI face, beside the film's.
• look-audit.py reads the finished film's type: type-read fails when the largest line is under 6.7 % of the frame height (72 px at 1080p) or reads under 3:1 against its ground, and type-beat warns when no line sits large on a clean field for a second. The layout audit's role bands hold both families, and grammar-score.mjs re-measures type from the layout boxes.
• Gradient fills clipped to type keep their descenders (clipText, bandFill, frontFill). lint-film.mjs warns on an unpadded background-clip: text and on SVG <text> in an act.

Real marks and icons

• scripts/logos.mjs (search, get, list, check) fetches the official colour marks of the products a product works with (its integrations, sources, models and platforms) from SVG Logos, svgl, Simple Icons and Wikimedia Commons, with each file's licence gated. get writes the mark, its version for dark grounds, the wordmark and one-colour files into public/logos/ with their colours unaltered, and records source, licence and trademark owner in logos.json, never on screen; src/logos.ts indexes them for the kit. A brand's full-colour mark or app tile wins over a one-colour glyph or an older drawing, unless the brand's own colour is black or white.
• kit/logos.tsx sets the marks as AppIcon tiles, LogoChips, InlineLogos at cap height inside a line, LogoWalls and LogoRings, in the colours and proportions they are published in.
• The capability reel's ring, the walkthrough's input and the camera teaser's connect line show real marks by default; a text pill stands in until a mark is fetched.
• Real marks appear only for what the product really touches, never implying endorsement (references/brand-and-color.md §1b).
• look-audit.py leaves the pixels of every recorded mark out of the colour rules, following the mark wherever the film draws it.
• Generic glyphs are Phosphor Icons 2.1.1 (MIT) in line, bold, fill and duotone, in place of the hand-drawn set, with twelve more names.

Depth, light and dense UI

• Lit tilts a product panel 8–14 degrees in the film's one light (FILM_LIGHT): a rim on the edges that face the key, a lift of 5 % at most on the side that turns to it, a 3 % sheen along the key edge, a cast and a contact shadow, and a sway that never rests. No veil lies over the product.
• DepthStack sets a beat in three planes (far, mid, near) at fixed defocus levels with parallax, and depthPush moves the camera through them. Every item says what it carries (UI, text, a mark, an icon, a photo, data), and depthFiller() lists one that carries nothing; the near plane fades as the push passes it and is gone before it lands. camera3d, swing3d, place and cam3dCheck give a UI film its one 3D turn, 15–30 degrees on one axis, and the check measures the move that turns most.
• LitGround builds the place in code. A flat field or a wash keyed from one side (a lightness swing of 0.02–0.10, 0.06 by default) are the house grounds, dealt so that no ground holds more than two shots in a row; pools, bars, a floor glow and window beams come only when a film names them because its place has that light. Planes draws the background, middle and foreground under one camera.
• KeyLight and ReliefScene give a directional key with cast and contact shadows over a lit relief, and LightField gives living light over baked plates, for a place's own light or a light event, never as the default ground. Light, glow, glass, spectral colour and multi-hue gradients are allowed as part of a device with a job, always baked and dithered. Every light has a source the picture could have and is felt more than seen (references/lighting.md).
• DenseScreen shows the product in use: the app's chrome around a records table, figures, a feed and a chart, 25 to 200 strings as texture, and exactly one line held readable by FocusLens, whose lens glides on E.glideOut with one readable line through the glide.
• sampleWorld(seed) deals a believable workspace whose numbers add up (statuses agree with dates, totals with their rows), seeded by the film so that two films never share data. checkWorld() asserts it.
• People are crafted portraits (Avatar, AvatarStack, a halftone portrait), never grey silhouettes or circles of initials; initials appear only as a monogram tile on a 24–40 px chip.
• ContentTile, ContentWall, ContentRing and ContentTicker fill walls, rings and tickers with tiles that carry content (a real mark or a glyph, a label, a small preview), never a blank tile.

Direction, brand kits and pictures

• scripts/deck.py deals three complete art directions that fit the brief from 35: 26 in worlds built in code and 9 where the product's own photographs or footage are the world. Each has its space, light, camera language, cut grammar, type behaviour, story shape, lockup, palette proportions, one signature shot and an update-film variant; its planes are real cards, chips, tiles and marks of the product, never blank shapes, and its light is motivated and subtle. Type-led and graphic directions are favoured; imagery-led ones are dealt only with --have photos or --have footage. Every printed command carries --recent, so a deal can be reproduced.
• The device book, references/devices/, holds 466 devices in 25 family files with an index that picks by job. pick.py draws a film's picture plan and its line track from 724 entries in 27 families, follows --have and the dealt direction, and never draws a technique that breaks a hard ban.
• scripts/brand.py takes in a supplied kit (a logo, colours, fonts, screenshots, product photos) and writes brand/brand.json, the tokens, the fonts on the weights the kit supplies, and the logo split into parts for Mark and Wordmark. The kit's own greys become the grounds. new-film.sh --brand runs it; references/brand-kits.md is the guide.
• scripts/like.py measure turns a clip the user supplies into the film's grammar targets (shot lengths, cut rhythm, camera activity, curve families, type scale, density, palette proportions, tempo), and like.py guard checks that the finished film borrows the grammar and not the content. new-film.sh --like runs it; references/clip-match.md is the guide.
• Pictures are an accent: the product's own or supplied ones first, a found one only when it carries the idea. scripts/assets.mjs searches open collections whose licences need no credit, shows a sheet, downloads with a private licence record, grades a set into one natural look and checks it. Photo, Footage, Montage, TypeMask, Cutout and Lens move them. Credits never go on screen.
• Colour: neutral grounds and surfaces (the mid slate is the dark default), one accent on what matters, and an optional support hue in 10–30 % of the film.

Motion gates and the checks

• forensics.py gains six motion gates that fail the film: one-frame snaps outside a declared snap (one declared snap device per film), frozen runs, moves that settle too fast, more than two primary moves in 3 s, moves that stop dead, and cuts into a braking move. A declared stepped range hides a one-frame image only when it has no cadence or its poses last under 2 frames.
• lib/continuity.ts gives the fixes: glideValue and glideList (a state change glides over 16 f on E.glideOut), holdDrift (0.3–1 px a frame through every hold), landBeforeCut (it throws when a cut or an unmount falls mid-move) and latestStart. fx/GlideStep is the gliding list. The starter's own moves pass the gates: TypeClaim's hold creeps once the claim is built and never stops dead, and InlineObject and InlineLogo roll over 16 f on E.glideOut, a new object every 48 f.
• lint-film.mjs warns on the same in the source (snap-step, hold-drift, unmount-moving, move-queue; a line snap counts as declared only through LineSnap's own declares()), and on card content, small text, the giant word, the end-card template, undeclared device palettes and deprecated tokens.
• No filler: every element in frame has a job (references/taste-and-slop.md). look-audit.py fails faint shapes on the ground that carry no text, icon or mark (filler-shape) and a pool, a white haze or a fog vignette over the ground (ground-haze). lint-film.mjs warns on blank plates, depth items that carry nothing (filler-plate) and light pools, glows or haze that no named light motivates (filler-light; cinetic:light <what it is> names one).
• look-audit.py fails a render under the motion floor (the camera or the ground moving on 70 % of the body, with a lock of up to 1 s on each read counted as alive; two planes at different rates; carried seams; a designed moment every 3 s; a light event in every act; scale changes across cuts) or the picture floor (some clean flat ground, a ceiling on edges, colour mass, bleed). It also checks the accent, the support hue, a colour-wash ceiling and the type.
• grammar-score.mjs scores a film against the house grammar, or against a supplied clip's.
• grid-check.ts checks the music grid, shot bands per format (LOOK.filmType takes update), a picture change every 2.5 s and two in the opener, long takes, the cut mix and the script rule.
• The review loop reads feed-size strips (six frames over 2.5 s at 240 px) for the opener, the signature and type beats and the lockup, and from round 2 runs a blind pair test against clips the user names as the bar. The ship gate's rubric gains a Picture dimension: 12 dimensions, Picture at 4 or more.
• The layout audit measures the text's own size, cuts each box by its clipping ancestors, reads a ghost or a smear once, and leaves smears and scrolling rows out of the speed check.

Sound: the music finder, the library and real effects

Every film is cut to its own licensed, human-made, instrumental track, and every effect is cast for the action it sounds.

• scripts/music.mjs search finds the track in free catalogs whose licence needs no credit (Mixkit, and CC0 recordings from Wikimedia Commons, ccMixter and Openverse), ranked by the brief's mood words, tempo, length and energy curve. sheet --measure lists the first three to audition; get reads the licence page again, downloads the file and writes its licence record. A catalog that fails the licence bar is named with its reason and never requested.
• music.mjs pick ranks a curated music library of analysed tracks (--library, $CINETIC_MUSIC_LIBRARY or ~/.cinetic/music-library.json) by mood, length and tempo, each with its cut points, with the offers spread across artists. The history holds back every track an earlier film used.
• scripts/audio/track.py (add, analyze, edit, grid, check) writes the licence record, analyses tempo, bars, phrases, entries, stops, the ending and the key (an unchanged analysis is kept), edits at bar lines (--map takes the bars by hand), writes the film's grid in src/music.ts and points audio/score.json at the edit.
• kit.py cast gives each action in the film its own sound (a card landing, a toggle, typing, a swipe, a logo lock, a transition through a shape; scripts/audio/actions.py), in the order earshot's ears rank them, checked for masking where each action lands on the track, and avoids the last film's signature sounds. --avoid replaces a sound the film's listening judged poorly. Takes alternate, so the same take is not heard twice within 3 s.
• Real effects where the bank is weak: music.mjs search --kind sfx and get find a free effect that needs no credit, and kit.py real makes it an action's takes. scripts/audio/library.py (add, listen, list, check) keeps a library of real effects by action, each cut to one gesture and levelled. kit.py cast draws from the bank and the library together, matched to the track's tempo, band and key, so no two films share one set.
• plan.py lays the effects out over the bed: each role at its level, a stop-down before each hit that matters instead of ducking, and at most 10 effects in any 10 s. score.py mixes and masters to −14 LUFS (−16 for a sting of 8 s or less), and its masking check reads an effect's attack. credits.py writes any credit into the delivery folder, never into the picture.
• earshot 0.4 and its launch kit. score.py --draft plays placeholder voices for a timing check, and deliver.sh, credits.py and av-audit.py refuse that build.

Rendering and Windows fixes

• render.sh renders previews and masters in parts of 300 frames from a bundle built once into out/render/<name>/. A render stopped by a job time limit, a crash or --max-min (exit 75) resumes on the next run, --part K renders one part, and the join writes BT.709 into the stream and the container. The parts stay until every gate has passed; deliver.sh removes them, and --clean and --keep handle them by hand.
• scripts/py.mjs is the one way every script, npm script and test finds Python: $PYTHON, else $CINETIC_PYTHON, else the first of python3, python and py -3 that runs 3.10 or newer and imports numpy. It never runs the Microsoft Store alias, and --which prints its choice.
• Under Git Bash on Windows, render.sh, deliver.sh, hf-finish.sh and brand-kit.sh pass paths to Python as arguments and check the modules a run needs before the bundle, and new-film.sh runs every Python step through py.mjs.
• render.sh and layout-audit.sh clamp --concurrency to the cores Remotion sees, and the layout audit reads its output with colour on.
• new-film.sh --music refuses before copying anything when a licence field is missing. Without --bpm at 25 fps, a scaffold takes the nearest tempo with whole-frame beats. The first act starts on frame 0.
• Footage and Montage draw clips on a shifted Sequence, because a Freeze does not reach OffthreadVideo's clock in Remotion 4.0.529.
• blurBridge, DirBlur and camVel give the same result at any frame size. TypeOn counts characters as code points. add-font.mjs --add writes its key only inside FONT. track.py writes a drift it could not measure as null, never NaN. kit.py tune moves notes by whole octaves into each sound's range.

Starters, evals and tests

• The starter demo runs 15 s in four acts that each open on a bar line (seven bars, and a tail that holds a stop ending): "plinth cuts" and "to music." build around an accent dot that lands as the line's full stop, the line launches left into a picture slot, the picture contracts into the gap of "Cuts land.", and the mark lands as a relief under a turning key before the name rises whole through its slot. Its audio/score.json plays the track the user adds.
• The HyperFrames starter uses the 1.2 easing names, loads music.js before timeline.js and plays a licensed track.
• SKILL.md follows the 1.2 workflow from the brief, the dealt direction and the script to the ship gate (Steps 0–11). The critics judge the script as a stranger would, ask for a different text animation on every line and a picture that never rests.
• Evals: Lattice, a 25 s launch film cut to music, and Ferry, a 15 s v2 update video in a supplied brand. Both check the licence record, no credit on screen, cuts at bar lines and effects at their levels over the bed.
• New tests in scripts/test/ cover copy-check, the type presets, type moves and type families, the primitives, continuity, handoffs, depth and light, the dense kit, the product moment, the wordmark, logos and the logo kit, the music finder, the cast and the sound library, the track, brand intake, clip match, the deck, imagery, render parts, the HyperFrames mirror and provenance (house wording, no audio in git).

Removed

• The generated band ("music": "synth" exits 1, and sections, motifs, drums, pads and arps are ignored), the sidechain, the hit and typing ducks and the suck. synth.py is split into dsp.py and draft.py.
• The fallback to generated effect voices when no kit is rendered. kit.py init starts from the launch kit; the effects-only presets stay for older projects.
• The hand-drawn glyph set, and the grey silhouette and circle of initials as avatars.

---

Install with the skills CLI: npx skills add Leonxlnx/cinetic

Or download cinetic.skill below: a zip of the skill folder with cinetic/SKILL.md at its root.