Skip to content
Back to search

FableCut

Zero-dependency browser video editor that AI agents can drive — JSON timeline, MCP + REST, live-reloading UI

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/ronak-create/FableCut with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/ronak-create/FableCut'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ronak-create--fablecut/badge.svg)](/listings/ronak-create--fablecut)

HTML

<a href="/listings/ronak-create--fablecut"><img src="/api/listings/ronak-create--fablecut/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/ronak-create/FableCut.git
cd FableCut
node server.js        # → http://localhost:7777

Requirements: **Node 18+** and a Chromium-based browser. **ffmpeg on PATH** is optional but recommended (fast export + upload remuxing). AI background removal fetches its model from a CDN on first use.

The server binds **127.0.0.1 only** (v1.3.1+). To use it from another device on your LAN, opt in explicitly: `HOST=0.0.0.0 FABLECUT_ALLOWED_HOSTS=<your-ip> node server.js`.

Drop media into the window (or `./media/`), paste an HTTPS URL via **+ URL**, drag clips onto the timeline, edit, export.

To keep your work outside the checkout, set **`FABLECUT_DATA_DIR`** — it moves `project.json`, `media/`, `exports/`, `analysis/` and `library/` to a directory you choose. Leave it unset and everything stays in the repo, exactly as before.

Or install it as a Claude Code plugin

/plugin marketplace add ronak-create/FableCut
/plugin install fablecut@fablecut

That registers the MCP server for you and adds two skills — `edit-video` and `remake-reel`. Your timeline and footage live in the plugin's own data directory, so an update never touches them. Node 18+ and (optionally) ffmpeg still need to be on your machine.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "fablecut",
  3. "owner": {
  4. "name": "Ronak Parmar",
  5. "url": "https://github.com/ronak-create"
  6. },
  7. "description": "FableCut — a browser video editor that AI agents can drive.",
  8. "plugins": [
  9. {
  10. "name": "fablecut",
  11. "source": "./",
  12. "category": "media",
  13. "tags": ["video", "video-editing", "captions", "ffmpeg", "mcp"]
  14. }
  15. ]
  16. }
README.md · README · 681 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="docs/fablecut-banner.png" alt="FableCut" width="800">
  3. **A browser video editor that AI agents can drive.**
  4. <a href="https://trendshift.io/repositories/77702?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-77702" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/77702/daily?language=JavaScript" alt="ronak-create%2FFableCut | Trendshift" width="250" height="55"/></a>
  5. [![Hacker News — front page](https://img.shields.io/badge/Hacker%20News-front%20page-ff6600?logo=ycombinator&logoColor=white)](https://news.ycombinator.com/item?id=48845422)
  6. [![DEV — Top 7 of the week](https://img.shields.io/badge/DEV-Top%207%20of%20the%20week-0A0A0A?logo=devdotto&logoColor=white)](https://dev.to/devteam/top-7-featured-dev-posts-of-the-week-815)
  7. [![Official MCP registry](https://img.shields.io/badge/MCP%20registry-io.github.ronak--create%2Ffablecut-7b6cff?logo=modelcontextprotocol&logoColor=white)](https://registry.modelcontextprotocol.io/v0/servers?search=fablecut)
  8. [![Mentioned in Awesome MCP Servers](https://awesome.re/mentioned-badge.svg)](https://github.com/punkpeye/awesome-mcp-servers)
  9. [![Glama score](https://glama.ai/mcp/servers/ronak-create/FableCut/badges/score.svg)](https://glama.ai/mcp/servers/ronak-create/FableCut)
  10. [![Glama — #18 Best Browser Automation MCP Servers](https://img.shields.io/badge/Glama-%2318%20Best%20Browser%20Automation-0e1618)](https://glama.ai/mcp/best/browser-automation)
  11. [![Docs](https://img.shields.io/badge/Docs-fablecut.space%2Fdocs-7b6cff)](https://fablecut.space/docs/)
  12. [![Discord](https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white)](https://discord.gg/EFMQH7d6Tv)
  13. **English** · [简体中文](docs/i18n/README.zh-CN.md) · [日本語](docs/i18n/README.ja.md) · [Español](docs/i18n/README.es.md) · [Português (BR)](docs/i18n/README.pt-BR.md)
  14. </div>
  15. [![Watch the FableCut Studio demo: an agent cuts a reel live (58 s)](docs/showcase/fablecut-studio-demo-play.jpg)](https://fablecut.space/showcase/fablecut-studio-demo.mp4)
  16. FableCut is a Premiere-style non-linear video editor that runs entirely in your
  17. browser — and exposes its whole timeline as one JSON document. Edit it by hand,
  18. from the UI, or let an AI agent (Claude Code, Claude Desktop, or anything that
  19. speaks MCP/REST) cut your video for you while you watch the timeline update
  20. live.
  21. Zero npm dependencies. One `node server.js`. That's it.
  22. ![FableCut editor](docs/screenshot.png)
  23. ## Why it's interesting
  24. Most "AI video" tools hide the edit behind an API. FableCut flips that: the
  25. **project file is the interface**. `project.json` describes media, clips,
  26. tracks, effects, keyframes and transitions — any process that can write JSON
  27. can edit video, and the open browser UI hot-reloads within ~150 ms via
  28. server-sent events. A human and an agent can work on the same timeline at the
  29. same time.
  30. **Taking back what the agent did.** Every agent edit is one undo step of its
  31. own: Ctrl+Z takes back the agent's last change first (and says so), then
  32. goes on to yours, so the two never get mixed. For bigger rollbacks there are
  33. **Versions**: one is kept when an agent starts editing (again at most every
  34. 10 minutes while it works), before it rewrites the whole project, before every
  35. big operation (cutting silences, snapping to the beat, reframing), and every
  36. 10 minutes while you edit. Restore one from the Versions panel, or ask the agent
  37. (`fablecut_versions`), and compare any version with now first.
  38. ## Features
  39. **Editing**
  40. - Video + audio tracks (default 3+4; add more with **+V** / **+A** in the track
  41. header; right-click an empty header → **Remove track**), drag/trim/split/snap,
  42. undo/redo
  43. - **Settings** (cog in the top bar) — optional prefs stored in this browser via
  44. `localStorage`. Enable **Link timeline and Project bin selection** so picking a
  45. timeline clip highlights its media in Project, and clicking a Project item
  46. selects every timeline clip that uses it (off by default).
  47. - Video + audio tracks (default 3+4), drag/trim/split/snap, undo/redo
  48. - **+V** / **+A** in the track header add a video or audio lane (up to 16 each)
  49. - Right-click an empty track header → **Remove track** (disabled if the lane
  50. has clips, or if it would leave you with zero video/audio tracks)
  51. - Track header **S** solos that lane (mutes all others); click again to restore
  52. the previous mute state. Using the mute toggle while soloed exits solo.
  53. - **Track targeting** — click a track's name to target / untarget it (lit =
  54. targeted). Split, insert, ripple, close gap and jump-to-cut touch targeted
  55. tracks only; the eye / speaker toggle is output-only (hide from preview and
  56. export) and no longer blocks edits. A selected clip is edited wherever it sits.
  57. - **Track lock** — the padlock in the track header. Nothing on a locked track
  58. can be moved, trimmed, split or deleted, and ripples leave it in place while
  59. the other tracks shift — lock the music bed and re-cut the picture freely.
  60. - **Clip lock, disable and unlink** — right-click a clip (or use the toggles at
  61. the top of the inspector): **Lock** pins it like a locked track; **Disable**
  62. (<kbd>⇧E</kbd>) keeps it on the timeline but hides it from preview and export;
  63. **Unlink** (<kbd>Ctrl/Cmd+L</kbd>) splits a video from its audio so they move
  64. separately, and **Link** re-joins them once they line up again. Agents see
  65. locks too: `fablecut_patch_project` refuses to edit locked clips unless the
  66. op says `force: true`.
  67. - Dropping a video with more audio channels than A-tracks **adds the missing
  68. lanes automatically** (up to 16) and toasts how many were added; each channel
  69. becomes a linked stem on its own A-track
  70. - **Direct manipulation on the monitor** — click a clip or title on the preview to
  71. move, resize (corner handles), or rotate (top handle, Shift-snap) it directly
  72. - **Timeline multi-select** — rubber-band marquee (drag on empty track area),
  73. <kbd>Ctrl/Cmd/Shift+click</kbd> to add/remove clips, <kbd>Ctrl+A</kbd> to
  74. select all, <kbd>Esc</kbd> to deselect. Drag any selected clip to move the
  75. whole group; <kbd>Delete</kbd> removes all selected; <kbd>S</kbd> splits all
  76. selected at the playhead. Inspector shows an "N clips selected" banner.
  77. - Beat & cue markers (tap <kbd>m</kbd> on the beat during playback) — name and colour them, drag them on the ruler, jump with <kbd>⇧m</kbd> / <kbd>Alt+⇧m</kbd> or the **Markers** list; snapping targets (clip edges, playhead, markers, IN/OUT, keyframes, frame grid) are picked from the **▾** beside Snap
  78. - Press <kbd>Alt+t</kbd> to add an in/out transition based on the playhead position over the selected clip. The last used transition is remembered as the default. Drag the overlay triangle to adjust duration; <kbd>Delete</kbd> clears the focused transition.
  79. - Real decoded audio waveforms on clips
  80. - **Mixer** — the **Mixer** tab beside the Inspector has a strip per audio
  81. track (fader, pan, mute, solo, meter) and a master fader with a live LUFS
  82. readout. Preview and export run through the same mix, so what you hear is
  83. what renders.
  84. - **Clip gain, channels and Normalize** — each audio clip has a **Gain** (dB,
  85. before volume and keyframes), a **Channels** mode (stereo, mono, left,
  86. right, swap) and **Normalize**: measure the selected clips (ITU-R BS.1770
  87. loudness or sample peak) and set their gain to hit −14 / −16 / −23 LUFS or
  88. −1 dBFS. Linked stems share one gain so a stereo pair stays balanced.
  89. - **Volume line, fades and crossfades** — every audio clip shows its volume as
  90. a line you drag; Ctrl/Cmd-click adds a keyframe, Alt-click removes one. Corner
  91. grips drag fades in and out, drawn with their real curve (constant power,
  92. constant gain or exponential). **Shift+D** crossfades the cut next to the
  93. selection, borrowing spare media from both sides so nothing else moves.
  94. - **Auto-duck** — select the music, pick the dialogue track and an amount, and
  95. the music dips wherever someone speaks (ramping down just before, back up
  96. after). It rides on top of the music's own volume, so re-running or clearing
  97. it never touches your levels. Agents use `fablecut_auto_duck`.
  98. - **Audio effects and presets** — EQ, high/low-pass, compressor, limiter,
  99. noise gate, delay, reverb, distortion, stereo width and pitch shift, chained
  100. per clip, per track (Mixer → **FX**), per bus and on the master. Presets:
  101. Clean voice, Podcast, Radio, Deep voice, Telephone, Cinematic, Wide and
  102. Muffled, all tweakable afterwards. Preview and export run the same effects.
  103. Agents use the `setFx` patch op.
  104. - **Effect automation** — the ◆ beside an effect setting keys it at the
  105. playhead, like clip keyframes: sweep a filter into the drop, open up a
  106. reverb at the end. Agents use `setFxKeys`.
  107. - **Submix buses** — **+ Bus** in the Mixer adds a bus with its own effects,
  108. fader, pan, mute and meter; route tracks into it from the menu under each
  109. track's name (all the dialogue through one compressor and one fader).
  110. - **Noise reduction** — the inspector's **Noise** control (Light / Medium /
  111. Strong) measures the file's noise floor and renders a cleaned copy with
  112. ffmpeg; the clip's audio switches to it and **Off** switches back. Agents
  113. use `fablecut_denoise`.
  114. - **Reframe** — make a 9:16, 1:1 or 4:5 copy of your edit whose shots follow
  115. the subject: a virtual camera pans after what matters in each shot and
  116. writes ordinary position keys you can still edit. From **New sequence…**
  117. or the Inspector's **Reframe** section; agents use `fablecut_reframe`.
  118. - **Highlights** — the best moments of long footage (movement, sound, a
  119. clear picture) cut into a short edit in a new sequence, in story order and
  120. never across a cut. From the sequence menu's **Highlights…**; agents use
  121. `fablecut_highlights`.
  122. - **Silence removal** — the inspector's **Silence** section (or right-click →
  123. **Find silences**) listens to a take and marks every pause on the timeline;
  124. **Cut** extracts them all in one undo step, keeping a little quiet beside
  125. each phrase so words aren't clipped. Agents use `fablecut_silence`.
  126. - **Beats** — the inspector's **Beats** section finds a music clip's tempo, a
  127. steady beat grid and the drop, and shows the beat across the timeline. Mark
  128. the beats, snap every cut onto the nearest one, or re-cut a track so each
  129. shot lasts 1, 2, 4, 8 or 16 beats. Agents use `fablecut_beats`.
  130. - **Transcripts and text-based editing** — the **Transcript** tab turns speech
  131. into words with times, in the browser (Whisper; the model downloads once and
  132. the audio never leaves your machine). Click a word to go there, select words
  133. and press Delete to cut them, or find a phrase and cut every time it is said.
  134. Agents use `fablecut_transcribe` to read an interview, find a line and cut it.
  135. - **Captions** — one click makes captions from the transcript, timed word by
  136. word: subtitle, karaoke, a highlighted word or big popping words, sized for
  137. the canvas. Export or import SRT and WebVTT. Agents use `fablecut_captions`.
  138. - **Project bin folders** — tree view with expand/collapse; drag media or folders to nest; right-click the **Project** tab → New folder; drop files onto a folder to import into it
  139. - **Media management** — each file's frame rate, codecs, audio channels and size (ffprobe); search by name, codec, resolution or `#tag`; filter by favorites, used / unused, kind, tag or collection; sort by any detail or by times used; a list view with metadata columns; favorites, tags and collections; **Find timeline instances** and **Reveal in project**; offline files flagged with a "Media offline" slate, **Relink…** (finds moved files by name and size) and **Replace file…**
  140. - **Projects** — a dashboard of every project with pictures, notes and tags: open, create from a canvas or a saved project template, duplicate, rename, archive and delete, import an old project file; media is shared, so copies cost no footage
  141. - **Sequences** — several timelines in one project (a 16:9 and a 9:16 cut, cut-downs, alternatives) sharing its media and compositions, each with its own canvas, frame rate, mix and delivery settings; switch from the menu at the left of the timeline toolbar
  142. - **Versions** — non-destructive history: save a version (Ctrl/Cmd+S), automatic versions every 10 minutes and before an agent edits, compare a version with now, restore (the current state is kept as a version first), mark the final cut; backups carry every version, and an unreadable `project.json` is recovered at startup
  143. - **Proxies** — light, frame-accurate H.264 copies of 4K / HEVC / ProRes footage made in the background (ffmpeg); edit on the proxy with the monitor's **Proxy** button, export always renders the originals
  144. - **Import from URL** — **+ URL** downloads an HTTPS video/audio/image into
  145. `./media/` (same-origin after import). Remote SVG is refused. Agents use
  146. `fablecut_import_media` with an `https://` path. The URL is not kept as
  147. `media.src` — that would taint the canvas and break export.
  148. - **Audio Hold** — timeline toolbar toggle: while paused, loops **one frame** of
  149. audio at the playhead (useful when stepping frame-by-frame). Scrubbing or
  150. frame-step retargets the held slice; meters stay live. **Play** / **Pause**
  151. turns it off.
  152. - Canvas aspect presets (16:9, 9:16 reels, 4:5, 1:1) + project FPS select
  153. (24 / 25 / 30 / 50 / 60; non-preset rates show as Custom) + safe-area guides
  154. - **Export frame / reframing** — composition canvas can be larger than the delivery
  155. crop (`exportFrame` in `project.json`). Preview dims the overscan; drag the
  156. **Export frame** handle to reframe (e.g. 16:9 canvas → 9:16 export). Fast export
  157. crops to the frame; WebCodecs and Realtime export are disabled while a frame is set
  158. - **Program Monitor zoom** — mouse-wheel over the preview zooms the composition
  159. toward the cursor (fit → up to **2 screen pixels per canvas pixel**). Magnified
  160. view uses **native scrollbars** so overflow stays reachable; middle-click or
  161. <kbd>Alt</kbd>+drag pans. The **Fit** button (shown while zoomed) resets to the
  162. fit-to-stage baseline
  163. - Full **J**/**K**/**L** shuttle — <kbd>L</kbd> plays forward, <kbd>J</kbd> in reverse; tap
  164. again for 1.5×/2×/4×, the other key turns around, <kbd>K</kbd> stops. Hold <kbd>K</kbd> and
  165. tap <kbd>J</kbd>/<kbd>L</kbd> to step a frame, or hold both to crawl at ¼ speed. Preview
  166. only, never the export
  167. - Typed timecode — click the playhead readout (or type digits) to jump: `01:15:00`,
  168. `1500`, `+30`, `12.5`; the IN / OUT readouts take typed times too
  169. - Resizable workspace: drag the divider between monitor and timeline (double-click resets), plus S/M/L timeline track-density presets (S hides thumbnails for compact tracks)
  170. - **Zoom to selection** (<kbd>⇧Z</kbd>) frames all selected clips, not just one
  171. - **IN/OUT work area** — set markers with <kbd>i</kbd> and <kbd>o</kbd> (<kbd>⇧I</kbd> / <kbd>⇧O</kbd> to clear). The Program Monitor shows playhead as `current / sequence duration`; when markers are set, IN, marked duration, and OUT stack on the right. **Export** has a Range dropdown (Entire timeline / IN–OUT; defaults to IN–OUT when markers exist) so you can keep markers for split/trim and still export the full sequence. Enabling **Limit** constrains playback to the marked range and maps <kbd>Home</kbd> / <kbd>End</kbd> to the IN and OUT positions rather than the full timeline. <kbd>t</kbd> splits clips at the markers; <kbd>⇧t</kbd> trims clips to the work (between marker in and marker out) area.
  172. - **Find & close gaps** — a gap is a stretch where every targeted track is empty (black frames). <kbd>g</kbd> jumps the playhead to the next shared gap (wraps; respects IN/OUT when both are set). <kbd>⇧G</kbd> closes the gap under the playhead by pulling later clips left on all targeted tracks (locked clips stay put).
  173. - **Trim tools** — a tool picker in the timeline toolbar (or <kbd>V</kbd> <kbd>B</kbd> <kbd>R</kbd> <kbd>Y</kbd> <kbd>U</kbd>): **Selection**, **Ripple edit** (drag a clip edge and everything after it follows, so no gap opens), **Rolling edit** (drag a cut between two clips; nothing else moves), **Slip** (change which part of the source a clip shows without moving it) and **Slide** (move a clip while its neighbours trim to make room). Every tool respects source length, targeting, locks and linked audio, and shows the offset beside the pointer while you drag. Agents run the same edits — split, ripple delete, lift / extract, insert / overwrite, ripple / roll / slip / slide and crossfade — as `fablecut_patch_project` ops, on the same code.
  174. - **Lift / Extract** — <kbd>;</kbd> removes the IN→OUT range on the targeted tracks and leaves the gap; <kbd>'</kbd> removes it and closes the gap. Both also sit in the timeline toolbar.
  175. - **Jump to cut** — <kbd>↑</kbd> / <kbd>↓</kbd> move the playhead to the previous / next edit (clip In or Out). With a clip selected, the first taps land on that clip’s start then end (Premiere-style); with no selection they walk cuts on targeted tracks. In the Source monitor they jump among 0, In, Out, and duration. Left/right still step frames; Home/End still go to the sequence (or IN/OUT with Limit).
  176. - **Ripple delete** — the timeline **Ripple delete** button (or <kbd>⇧Del</kbd>) removes the selection and pulls later clips left on each **targeted** track to close the gap; plain <kbd>Del</kbd> still lifts (leaves a gap). Linked AV partners always move together, even on untargeted tracks (sync lock); locked clips are never deleted or moved.
  177. - **Reset a property** — <kbd>Ctrl/Cmd+click</kbd> an inspector **label** or **slider** restores that effect/prop to its default *and* clears every keyframe on the channel (scale → 1, opacity → 1, paired fields like Crop L/R reset together; transition labels clear the in/out transition). <kbd>Shift+click</kbd> a label is playhead-local: if you are parked on a keyframe it removes **that** keyframe only; otherwise it sets the value at the playhead to the default (auto-keys if the channel is already animated).
  178. - **Replace media** — the inspector's **Source** button (any video/audio/image/svg
  179. clip) swaps the underlying file while keeping position, trim, keyframes,
  180. transitions and every effect. Pick another item already in the bin or
  181. **Browse file…** to import and replace in one step. A video's linked L/R
  182. audio companions are swapped along with it; a shorter replacement clamps the
  183. trim to fit and toasts that it did so.
  184. - **Multi-channel video audio** — a video with more than 2 audio channels gets
  185. a linked audio clip per channel, not just L/R (5.1, 7.1…). Extra audio
  186. tracks (A5, A6, …, capped at 16) are created automatically as needed;
  187. replacing a clip's media re-syncs the linked channel clips to the new
  188. source's channel count, adding/dropping extras and new tracks as needed.
  189. **Look**
  190. - 14 one-click filter presets (cinematic, teal-orange, noir, vintage, cyberpunk, sunset, midnight…)
  191. - **Adjustment layers** — one clip grades everything below it, Premiere-style
  192. - **Color workspace** (top bar → **Color**): live **waveform, RGB parade,
  193. vectorscope and histogram** beside the program monitor, and a **Color** tab
  194. that grades the selected clip on the GPU — **lift / gamma / gain / offset
  195. wheels**, exposure, white balance with a **picker** (click something white),
  196. blacks / shadows / midtones / highlights / whites, log-style contrast with a
  197. pivot, soft rolloff and saturation, plus **curves** — luma and R / G / B,
  198. hue vs hue, hue vs saturation, hue vs luma and saturation vs luma, with a
  199. picker that marks a colour from the monitor, and **layers** (secondaries):
  200. a correction limited by an HSL **qualifier** and / or an ellipse, rect,
  201. polygon, bezier or free-hand **mask** (feathered, invertible, keyframable,
  202. dragged on the monitor), with a matte view. Copy / paste a grade across shots.
  203. Agents grade with the `setGrade` patch op and read the result as numbers
  204. with `fablecut_scopes` (levels, clipping, colour cast)
  205. - Quick filter sliders: brightness/contrast/saturation/hue, **temperature & tint**,
  206. blur, grayscale/sepia/invert, **vignette**, animated **film grain**
  207. - 17 blend modes (screen, multiply, overlay, color-burn, exclusion, hue,
  208. luminosity…), fit modes (contain/cover/stretch),
  209. per-edge cropping, corner radius, flip H/V
  210. - **Masks** — isolate any part of a clip (video, image, SVG, text or an
  211. adjustment layer): rectangle, ellipse, **bezier pen** and **free-hand**
  212. shapes, several per clip, combined with add / subtract / intersect /
  213. difference, each with feather, expansion, invert and opacity, all
  214. keyframable (outlines morph). Draw and edit them on the monitor, with a
  215. matte view. Agents use the `setMask` patch op and measure with `fablecut_scopes`
  216. - **Shapes and motion graphics** — shape layers of rectangles, ellipses,
  217. polygons, stars, lines and pen-drawn bezier paths in groups, with fill,
  218. stroke, dashes and trim paths for draw-ons; null objects, parenting and an
  219. anchor point on every clip; every value keyframes, edited right on the
  220. monitor. Agents use the `setShape` and `setParent` patch ops
  221. - **Motion paths, motion blur and text on a path** — bend a clip's travel into
  222. a curve with handles on the monitor, turn it along the way, blur fast moves
  223. with a shutter angle (preview and export), and set titles along lines, arcs,
  224. circles or drawn paths. Agents use the `setMotionPath` and `setTextPath`
  225. patch ops
  226. - **Compositions** — nested sequences: build a lower third, a logo sting or a
  227. scene once and place it anywhere as one clip that moves, masks, grades and
  228. blends like a picture, while its video and audio play and export as usual.
  229. Open one to edit it on the timeline, or precompose a selection. Agents use
  230. the `addComp`, `inComp` and `precompose` patch ops
  231. - **Animation presets and templates** — 33 ready-made entrances, exits,
  232. emphases and loops that fit any clip where it sits, and templates (lower
  233. thirds, logo animations, 9:16 / 1:1 / 16:9 social layouts) whose text,
  234. colours and logo you fill in, each placed as its own comp. Save your own
  235. animations and comps to the library for every project. Agents use the
  236. `applyPreset`, `addTemplate` and `setTemplate` patch ops
  237. - **Motion tracking** — follow a point or a region (with its scale and
  238. rotation) through a video clip, then make a mask follow it or pin a title,
  239. sticker or any clip to it; the result is ordinary editable keys. Agents use
  240. `fablecut_track`
  241. - **Track mattes** — cut a clip with the picture on the track above by its
  242. alpha or its luma (inverted or not): text filled with video, shape reveals,
  243. texture cut-outs. The matte track hides itself. Agents use `setMatte`
  244. - **Chroma key** (green screen) with tolerance/softness + spill suppression
  245. - **AI background removal** (person cut-out, in-browser via MediaPipe)
  246. **Motion**
  247. - Keyframe animation on ~25 properties with easing
  248. - **Keyframe markers on clips** — diamonds on the clip body at each unique
  249. keyframe time (tooltip lists channels; a count badge when several share a
  250. time). <kbd>Ctrl/Cmd+←</kbd> / <kbd>Ctrl/Cmd+→</kbd> jumps the playhead to
  251. the previous / next keyframe (selected clips first, else clips under the
  252. playhead). Inspector fields show the interpolated value at the playhead;
  253. changing one updates the keyframe you’re on, or inserts one if that channel
  254. is already keyed. Dragging a clip in the program monitor (move / scale /
  255. rotate) writes the same way. The ◆ button adds a keyframe at the playhead, or removes
  256. the one you’re parked on; ✕ clears the whole channel. When the playhead is
  257. outside the selected clip, keyframed fields and ◆ buttons are disabled (they
  258. show the nearest edge value) — keyframe edits only apply where the playhead
  259. actually is; unanimated properties stay editable anywhere
  260. - **Keyframe graphs** — toggle a property’s curve in the inspector to show an
  261. interpolated value graph beside the program monitor; click the graph to seek
  262. - **Speed ramps** — keyframe `speed` and the engine time-remaps video *and* the
  263. export audio mix (the fast-into-slow-mo reel move)
  264. - **Camera shake** and **RGB-split/chromatic aberration**, both animatable
  265. - 17 transitions: fades, slides, wipes (4 directions), zoom, iris, spin, blur,
  266. whip-pan, **glitch**, **pop**
  267. **Text**
  268. - **Title styles** — one-tap cohesive looks (Impact, Elegant, Kinetic cut, Neon,
  269. Handwritten, Luxury, and more); new titles vary the font, placement and animation
  270. automatically instead of defaulting to one flat style
  271. - Kinetic captions: typewriter, word-pop, word-slide, karaoke, **letter-pop**,
  272. **wave**, **bounce**, **shake**, **clip-reveal**, **zoom-in**, **font-cut**
  273. (rhythmic typeface cuts), **rise-mask**
  274. - **Neon glow** for that TikTok caption look
  275. - Font editor: system fonts, drop-in custom fonts (`library/fonts/`), and **any
  276. Google Font by name** — loaded automatically
  277. - Gradient fills, outline, background pills, letter-spacing, line-height,
  278. weights, italic, uppercase, soft shadows
  279. - **Text layout** — horizontal Align: left / center / right / **justify**
  280. (extra spaces between words). Drag a title’s corner handles to create a
  281. **text box** (`boxW` / `boxH`); further corner drags resize it (opposite
  282. corner stays fixed; <kbd>Ctrl/Cmd</kbd> resizes from center; <kbd>Shift</kbd>
  283. locks aspect). Inside a box, text wraps at the fixed font size by default;
  284. enable **Scale to fit** to shrink the font so the whole block fits. **V-align**
  285. (top / middle / bottom) places the text block vertically in the box. Set Box
  286. W/H to `0` to return to hug-content sizing.
  287. **Animated SVG clips**
  288. - A first-class `svg` clip kind: CSS-`@keyframes`-animated SVGs render
  289. **frame-accurately** in preview and export (the compositor freezes the
  290. animation at any time). Agents can author their own vector overlays —
  291. lower-thirds, confetti, sparkles — as plain `.svg` files. Starters included.
  292. **Remake a reference video**
  293. - Give it a reference edit (a reel you like) and get back an **edit blueprint**:
  294. shot boundaries, music beats + BPM, a loudness curve, per-shot energy, the
  295. drop — plus the reference's **music track extracted** into your media, ready
  296. to rebuild the same idea with your own footage. Zero extra dependencies
  297. (ffmpeg does the decoding; onset/tempo detection is plain Node).
  298. `node analyze.js ref.mp4`, `POST /api/analyze`, or the
  299. `fablecut_analyze_reference` MCP tool.
  300. **Look at the footage**
  301. - An agent (or you, over REST) can fetch an actual **image** of any moment:
  302. `GET /api/frame?src=/media/x.mp4&t=3.2` returns a JPEG of that frame, and
  303. `&frames=12` returns a 4×3 **contact sheet** across the clip — a cheap survey
  304. of everything a 3-minute take holds. Grabs are cached under `analysis/frames/`.
  305. - The `fablecut_frame` MCP tool wraps it and returns the image inline, so a
  306. multimodal model can *look*. Pass a `time` instead of a `path` and it renders
  307. the **composed timeline** through the editor's own compositor — graded, all
  308. tracks, identical to what export produces — so "is this grade right?" and "what
  309. did I actually build?" have a visual answer.
  310. - Together with the analyzer above, agents pick footage by looking at it instead
  311. of guessing from an energy number.
  312. **Asset library**
  313. - `library/` folders surface as tabs in the UI: **Elements** (overlay art),
  314. **Sound FX**, **SVG** — drop files in, the open editor refreshes live
  315. **Export**
  316. - **Delivery presets**: YouTube, YouTube Shorts, Instagram Reels, TikTok, X,
  317. LinkedIn, Master, Broadcast (ProRes 422 HQ), Web, Archive (lossless FFV1) and
  318. Custom. Every setting is a control: resolution and reframing (crop, fit or
  319. stretch to another shape), frame rate, codec (H.264, HEVC, AV1, VP9, ProRes,
  320. DNxHR, XDCAM HD422, FFV1) and hardware encoder, CRF / VBR / CBR, max rate,
  321. keyframe interval, pixel format, color, container, audio codec, bitrate and
  322. rate, loudness normalization (−14 / −16 / −23 / −24 LUFS with a true-peak
  323. ceiling), a file-name template and metadata. Save your own presets; the
  324. dialog warns about upscaling, crops and platform limits before it renders,
  325. and every finished file is read back and checked — size, frame rate, frame
  326. count, codecs, length, loudness, true peak and file size
  327. - **Batch export**: one project → many files (master, YouTube 1080p, a 9:16
  328. reel, a square, a 720p preview…) from **one render per frame rate and
  329. range** (up to 8 outputs each) — every frame is drawn once and each output's ffmpeg
  330. encodes it. Batch outputs are saved with the
  331. project; an **export queue** runs them back to back with progress, stop,
  332. retry and open
  333. - Fast export: browser renders every frame + an offline audio mix; ffmpeg
  334. encodes them with a delivery preset, or a raw **encoding profile** from
  335. `encoding-profiles.json` (keeps rendering if you switch tabs). Encode and
  336. upload run ahead of the compositor so a fast timeline is not stalled by
  337. `toBlob`
  338. - WebCodecs export: the browser HW-encodes Annex-B H.264; the server
  339. stream-copies and muxes audio. Faster uploads; bitrate/VBR-CBR in the
  340. Export dialog. Unavailable while an export frame is set (use Fast)
  341. - Realtime MediaRecorder fallback when ffmpeg or WebCodecs isn't available
  342. - Agents export too: `fablecut_export` runs the Fast export in the open editor,
  343. or in a headless Chrome / Edge the server starts, and returns the file path;
  344. `preset` and `delivery` pick and adjust a delivery preset; `outputs` makes
  345. several files in one go
  346. - Export **Range** dropdown: Entire timeline or IN–OUT (defaults to IN–OUT when
  347. markers are set). Effective IN/OUT export bounds are clamped to `projDur()`.
  348. ## Quick start
  349. ```bash
  350. npx -y fablecut # → http://localhost:7777
  351. ```
  352. Your projects, media and exports go to `~/FableCut`. Or run it from a clone:
  353. ```bash
  354. git clone https://github.com/ronak-create/FableCut.git
  355. cd FableCut
  356. node server.js # → http://localhost:7777
  357. ```
  358. Requirements: **Node 22+** and a Chromium-based browser. **ffmpeg on PATH** is
  359. optional but recommended (fast export + upload remuxing). AI background
  360. removal fetches its model from a CDN on first use.
  361. The server binds **127.0.0.1 only** (v1.3.1+). To use it from another device on
  362. your LAN, opt in explicitly: `HOST=0.0.0.0 FABLECUT_ALLOWED_HOSTS=<your-ip> node server.js`.
  363. Drop media into the window (or `./media/`), paste an HTTPS URL via **+ URL**,
  364. drag clips onto the timeline, edit, export.
  365. To keep your work outside the checkout, set **`FABLECUT_DATA_DIR`** — it moves
  366. `project.json`, `media/`, `exports/`, `analysis/` and `library/` to a directory
  367. you choose. Leave it unset and everything stays in the repo, exactly as before.
  368. ### Or install it as a Claude Code plugin
  369. ```
  370. /plugin marketplace add ronak-create/FableCut
  371. /plugin install fablecut@fablecut
  372. ```
  373. That registers the MCP server for you and adds three skills — `edit-video`,
  374. `remake-reel` and `motion-graphics`. Your timeline and footage live in the plugin's own data
  375. directory, so an update never touches them. Node 22+ and (optionally) ffmpeg
  376. still need to be on your machine.
  377. ## Driving it with an AI agent
  378. Everything an agent needs is in **[CLAUDE.md](CLAUDE.md)** — the complete
  379. schema, semantics and recipes. Point any capable model at that file and it can
  380. operate the editor end to end.
  381. > 📖 **Browsable docs:** the same manual as web pages, one page per topic
  382. > (MCP tools, the `project.json` schema, clip props, recipes, REST API,
  383. > export): **[fablecut.space/docs](https://fablecut.space/docs/)**.
  384. Three equivalent control surfaces:
  385. 1. **MCP** (best for Claude Code / Claude Desktop) — register the bundled
  386. zero-dependency MCP server once:
  387. ```bash
  388. claude mcp add -s user fablecut -- npx -y fablecut mcp
  389. ```
  390. No clone or path needed; your work lives in `~/FableCut`. From a clone,
  391. point at the file instead:
  392. ```bash
  393. claude mcp add -s user fablecut -- node "<path-to>/fablecut/mcp-server.js"
  394. ```
  395. **OpenCode** can use the same stdio server from its project or global
  396. `opencode.json` configuration:
  397. ```json
  398. {
  399. "$schema": "https://opencode.ai/config.json",
  400. "mcp": {
  401. "fablecut": {
  402. "type": "local",
  403. "command": ["node", "/absolute/path/to/FableCut/mcp-server.js"],
  404. "enabled": true
  405. }
  406. }
  407. }
  408. ```
  409. For another MCP client, register a local stdio server with this equivalent
  410. command. The exact key names vary by client, but the command and arguments
  411. do not:
  412. ```json
  413. {
  414. "name": "fablecut",
  415. "transport": "stdio",
  416. "command": "npx",
  417. "args": ["-y", "fablecut", "mcp"]
  418. }
  419. ```
  420. (From a clone: `"command": "node"`, `"args": ["/absolute/path/to/FableCut/mcp-server.js"]`.)
  421. The server is intentionally client-neutral. It speaks MCP over stdio and
  422. does not require Claude-specific environment variables. With a clone, keep
  423. the path absolute. Node 22 or newer either way.
  424. Tools: `fablecut_status` (auto-starts the editor), `fablecut_docs`,
  425. `fablecut_get_project`, `fablecut_set_project`, `fablecut_patch_project`,
  426. `fablecut_import_media`, `fablecut_analyze_reference`, `fablecut_frame`,
  427. `fablecut_encode_profiles`, `fablecut_normalize_audio`, `fablecut_auto_duck`,
  428. `fablecut_denoise`, `fablecut_silence`, `fablecut_beats`, `fablecut_reframe`, `fablecut_highlights`, `fablecut_transcribe`, `fablecut_captions`, `fablecut_export`, `fablecut_scopes`, `fablecut_track`.
  429. FableCut is also published on the **official MCP registry** as
  430. [`io.github.ronak-create/fablecut`](https://registry.modelcontextprotocol.io/v0/servers?search=fablecut)
  431. — each release ships an MCPB bundle (`fablecut.mcpb`) that MCPB-capable
  432. clients can install directly.
  433. The surface is **token-efficient by design**: agents patch the timeline with
  434. small ops (`fablecut_patch_project`) instead of round-tripping the whole
  435. document, read a compact one-line-per-clip summary
  436. (`fablecut_get_project {compact:true}`), and fetch only the manual sections
  437. they need (`fablecut_docs {section:"props"}`).
  438. 2. **The file** — read `project.json`, modify, bump `revision`, write. The UI
  439. live-reloads.
  440. 3. **REST** — `GET/PUT /api/project`, `POST /api/upload`, `POST /api/import-url`,
  441. `GET /api/library`, `GET /api/export/profiles`, SSE at `/api/events`. See
  442. CLAUDE.md for the full list.
  443. Example: ask Claude Code *"cut these six clips to the beat markers, add a
  444. teal-orange grade, put a word-pop caption on top and a whoosh on every cut"* —
  445. and watch the timeline rebuild itself.
  446. Or hand it a reference: *"here's a reel I like — analyze it and remake it with
  447. my clips, same music"*. The agent calls `fablecut_analyze_reference`, gets the
  448. blueprint (cuts, beats, BPM, energy, drop, extracted music), and rebuilds the
  449. structure shot-for-shot with your footage.
  450. **The agent can see, not just measure.** `fablecut_analyze_reference` gives it
  451. the *ears* — where the cuts land, which shots hit hard. `fablecut_frame` gives it
  452. the *eyes*: ask for any moment of any clip (`{path, t:3.2}`) and the call comes
  453. back with an actual image the model can look at, or ask for a 12-frame contact
  454. sheet to survey a whole clip in one call (`{path, frames:12}`). Pass a `time`
  455. with no `path` and it renders the composed timeline — graded, all tracks, exactly
  456. as export would. So footage gets chosen by looking at it rather than guessing
  457. from a number, and a grade gets checked against the real picture.
  458. **Conflict-safe concurrent editing**: the UI, the MCP tools, and direct
  459. `project.json` writes all agree on a `revision` counter. If you edit a clip in
  460. the UI while an agent is mid-task, the agent's next write is rejected (409 from
  461. the REST API / a conflict error from `fablecut_set_project`) instead of
  462. silently overwriting your change. The UI similarly detects when an agent write
  463. supersedes a not-yet-saved local tweak and tells you with a toast instead of
  464. dropping it silently.
  465. ## Project layout
  466. ```
  467. server.js zero-dependency HTTP server: static hosting, REST API, SSE,
  468. ffmpeg export pipeline
  469. app.js the editor: timeline UI, compositor, keyframes, text engine,
  470. SVG rasterizer, chroma key, exporters
  471. index.html single-page UI
  472. style.css dark editor theme
  473. mcp-server.js stdio MCP server exposing the editor to AI agents
  474. analyze.js reference-video analyzer: shots, beats/BPM, energy, drop,
  475. music extraction (module + CLI)
  476. CLAUDE.md the agent manual (schema + recipes) — also served by fablecut_docs
  477. encoding-profiles.json
  478. Fast-export ffmpeg presets (hot-reloaded)
  479. project.json your timeline (created on first run; gitignored)
  480. media/ project footage (gitignored)
  481. analysis/ cached edit blueprints from /api/analyze (gitignored)
  482. library/ default assets: elements/ sfx/ svg/ fonts/
  483. exports/ finished renders (gitignored)
  484. ```
  485. ## Architecture Overview
  486. ```mermaid
  487. flowchart TD
  488. subgraph group_interaction["Editing Experience"]
  489. node_browser_ui["Browser Editor<br/>[app.js]"]
  490. node_timeline_model["Timeline Model<br/>[app.js]"]
  491. node_ruler_worker["Ruler Worker<br/>[ruler-worker.js]"]
  492. end
  493. subgraph group_project_media["Project And Media"]
  494. node_project_store[("Project Store<br/>[paths.js]")]
  495. node_media_store[("Media Store<br/>[paths.js]")]
  496. node_asset_library[("Asset Library<br/>[server.js]")]
  497. node_url_importer["URL Importer<br/>[import-url.js]"]
  498. end
  499. subgraph group_agent_api["Agent Control"]
  500. node_rest_api["REST Server<br/>[server.js]"]
  501. node_mcp_server["MCP Server<br/>[mcp-server.js]"]
  502. node_sse_hub["Change Notifications<br/>[server.js]"]
  503. end
  504. subgraph group_playback_export["Playback And Export"]
  505. node_compositor["Canvas Compositor<br/>[app.js]"]
  506. node_audio_engine["Audio Engine<br/>[app.js]"]
  507. node_audio_meter["Audio Meter<br/>[meter-worklet.js]"]
  508. node_export_engine["Export Engine<br/>[server.js]"]
  509. node_encoding_profiles["Encoding Profiles<br/>[encode-profiles.js]"]
  510. end
  511. subgraph group_analysis["Analysis Tools"]
  512. node_reference_analyzer["Reference Analyzer<br/>[analyze.js]"]
  513. end
  514. node_human(("Human Editor"))
  515. node_ai_agent(("AI Agent"))
  516. node_ffmpeg["FFmpeg"]
  517. node_human -->|"edits timeline"| node_browser_ui
  518. node_ai_agent -->|"sends tools"| node_mcp_server
  519. node_browser_ui -->|"updates project"| node_timeline_model
  520. node_timeline_model -->|"persists JSON"| node_project_store
  521. node_browser_ui -->|"calls REST"| node_rest_api
  522. node_rest_api -->|"reads writes"| node_project_store
  523. node_rest_api -->|"serves media"| node_media_store
  524. node_rest_api -->|"lists assets"| node_asset_library
  525. node_mcp_server -->|"checks server"| node_rest_api
  526. node_mcp_server -->|"patches project"| node_project_store
  527. node_mcp_server -->|"imports media"| node_url_importer
  528. node_url_importer -->|"stores downloads"| node_media_store
  529. node_rest_api -->|"downloads URLs"| node_url_importer
  530. node_rest_api -->|"broadcasts changes"| node_sse_hub
  531. node_sse_hub -->|"pushes changes"| node_browser_ui
  532. node_timeline_model -->|"renders timeline"| node_compositor
  533. node_timeline_model -->|"routes clips"| node_audio_engine
  534. node_audio_engine -->|"measures audio"| node_audio_meter
  535. node_browser_ui -->|"uploads frames"| node_rest_api
  536. node_rest_api -->|"streams export"| node_export_engine
  537. node_export_engine -->|"loads profile"| node_encoding_profiles
  538. node_export_engine -->|"encodes video"| node_ffmpeg
  539. node_reference_analyzer -->|"analyzes media"| node_ffmpeg
  540. node_reference_analyzer -->|"writes music"| node_media_store
  541. node_ai_agent -.->|"requests analysis"| node_reference_analyzer
  542. node_browser_ui -.->|"draws ruler"| node_ruler_worker
  543. click node_browser_ui "https://github.com/ronak-create/fablecut/blob/main/app.js"
  544. click node_timeline_model "https://github.com/ronak-create/fablecut/blob/main/app.js"
  545. click node_compositor "https://github.com/ronak-create/fablecut/blob/main/app.js"
  546. click node_audio_engine "https://github.com/ronak-create/fablecut/blob/main/app.js"
  547. click node_audio_meter "https://github.com/ronak-create/fablecut/blob/main/meter-worklet.js"
  548. click node_rest_api "https://github.com/ronak-create/fablecut/blob/main/server.js"
  549. click node_mcp_server "https://github.com/ronak-create/fablecut/blob/main/mcp-server.js"
  550. click node_sse_hub "https://github.com/ronak-create/fablecut/blob/main/server.js"
  551. click node_project_store "https://github.com/ronak-create/fablecut/blob/main/paths.js"
  552. click node_media_store "https://github.com/ronak-create/fablecut/blob/main/paths.js"
  553. click node_asset_library "https://github.com/ronak-create/fablecut/blob/main/server.js"
  554. click node_url_importer "https://github.com/ronak-create/fablecut/blob/main/import-url.js"
  555. click node_export_engine "https://github.com/ronak-create/fablecut/blob/main/server.js"
  556. click node_encoding_profiles "https://github.com/ronak-create/fablecut/blob/main/encode-profiles.js"
  557. click node_reference_analyzer "https://github.com/ronak-create/fablecut/blob/main/analyze.js"
  558. click node_ruler_worker "https://github.com/ronak-create/fablecut/blob/main/ruler-worker.js"
  559. classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
  560. classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
  561. classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
  562. classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
  563. classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
  564. classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
  565. classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
  566. class node_browser_ui,node_timeline_model,node_ruler_worker toneBlue
  567. class node_project_store,node_media_store,node_asset_library,node_url_importer toneAmber
  568. class node_rest_api,node_mcp_server,node_sse_hub toneMint
  569. class node_compositor,node_audio_engine,node_audio_meter,node_export_engine,node_encoding_profiles toneRose
  570. class node_reference_analyzer,node_human,node_ai_agent,node_ffmpeg toneIndigo
  571. ```
  572. ## Authoring animated SVG overlays
  573. SVGs animate with plain CSS `@keyframes`. One convention: never hardcode
  574. `animation-delay` — set `--d: 0.4s` instead, and the compositor drives time by
  575. pausing all animations and rebasing their delays. Full rules + a skeleton in
  576. [CLAUDE.md](CLAUDE.md#authoring-animated-svgs-the-svg-clip-kind); working
  577. examples in [`library/svg/`](library/svg/).
  578. ## Notes
  579. - The repo ships with **20 Google Fonts** (`library/fonts/`, OFL — see
  580. `LICENSES.md` there) and a set of self-authored SVG overlays and animated
  581. elements (`library/elements/`, `library/svg/`, MIT like the rest of the repo).
  582. - `library/sfx/` is yours to fill (gitignored): sound-effect sites typically
  583. don't allow redistributing their files in a public repo, so FableCut doesn't —
  584. `library/sfx/README.md` lists good free sources.
  585. - Export runs in the browser because the compositor *is* the browser; agents
  586. ask you to click Export (or render directly with ffmpeg from `media/`).
  587. ## Community
  588. Questions, ideas, showing off an edit, or want to help shape what's next? Join
  589. the **[FableCut Discord](https://discord.gg/EFMQH7d6Tv)**. Bugs and feature
  590. requests are still best filed as [GitHub issues](https://github.com/ronak-create/FableCut/issues).
  591. Rather email? Write to [hello@fablecut.space](mailto:hello@fablecut.space), or
  592. [support@fablecut.space](mailto:support@fablecut.space) for help.
  593. ## License
  594. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.