u/FastPresence9799

Sharing this here because I think this crowd will find the implementation more interesting than the video-editing part.

FableCut is a zero-dependency, browser-based NLE (Premiere-style: tracks, keyframes, transitions, kinetic captions, chroma key, the works). The whole project state lives in one JSON document. The MCP server (`mcp-server.js`) is a thin, dependency-free stdio JSON-RPC implementation — no MCP SDK, hand-rolled — that sits in front of it.

Seven tools:

* `fablecut_status` — auto-starts the editor if it's not running

* `fablecut_docs` — serves sections of the agent manual (CLAUDE.md) on demand

* `fablecut_get_project` — read the timeline, with a `{compact:true}` mode that returns a one-line-per-clip summary instead of the full doc

* `fablecut_set_project` — full document write

* `fablecut_patch_project` — **op-based patching**, so an agent nudging one clip's start time doesn't have to round-trip the entire timeline

* `fablecut_import_media`

* `fablecut_analyze_reference` — feed it a reference video, get back shot boundaries, beat markers, BPM, a loudness curve, per-shot energy, the drop, plus the extracted music track — a blueprint the agent then rebuilds with your footage

A few design choices I'd love feedback on:

* **Conflict-safe concurrent editing.** UI, MCP tools, and direct file writes all agree on a `revision` counter. If you hand-edit a clip in the browser while the agent is mid-task, its next write gets rejected with a conflict error instead of silently overwriting you.

* **Token efficiency was the actual design constraint**, not an afterthought — `patch_project`'s ops model and the compact read mode exist specifically because round-tripping a full timeline JSON on every tool call gets expensive fast once a project has more than a few clips.

* Install is `claude mcp add -s user fablecut -- node mcp-server.js` — it's now listed on the official MCP registry too.

It's also model-agnostic in the sense that MCP isn't the only surface — REST and direct file writes work identically, so anything speaking MCP (or nothing at all, just writing JSON) can drive it.

Repo + full tool docs: [https://github.com/ronak-create/FableCut\](https://github.com/ronak-create/FableCut) (see [CLAUDE.md](http://CLAUDE.md) for the schema agents actually read)


Genuinely curious if anyone's hit patterns for op-based patching on nested/array-heavy state that I should steal.

There are a lot of AI research tools that basically give you a chat box, a search bar, and a pile of tabs.

Burrow takes a different approach.

It gives you an infinite canvas — more like a digital detective board — where your AI assistant can actually work alongside you.

You can talk to it, bring in your own documents, search the web and research literature, extract information from PDFs, create notes, diagrams, tables and images, and have everything organized directly on the canvas.

The interesting part is that the canvas isn't just a UI for displaying AI responses.

The assistant can actually manipulate the board — create blocks, connect them, organize them into frames, flag uncertainty, read documents, search sources, and build out the research as you go.

A few things that stand out:

• 🎙️ Voice-first interaction with optional always-on wake-word mode
• 🧠 AI assistant with 15 tools for interacting with the canvas and research
• 📄 Import PDFs, Word docs, Markdown and text files
• 🔎 Search the web and academic literature
• 🧩 Notes, shapes, tables, diagrams, documents and images as native canvas blocks
• ✏️ Freehand drawing and handwriting support
• 🔗 Connect ideas visually instead of keeping everything in a chat history
• 🔐 Local-first — workspaces and transcripts stay as files on your machine
• 🔑 BYOK — use your own API keys and providers
• 🦙 Works with local models through Ollama and OpenAI-compatible endpoints
• 🎨 Light/dark mode with a deliberately minimal interface
• 🖥️ Built as a native desktop app with Tauri

The BYOK/local-first part is especially interesting.

You can point Burrow at Ollama or another OpenAI-compatible endpoint and run the assistant without handing your research workspace to another hosted platform. API keys can also live in the OS keychain.

The project is open source and currently available for Windows, macOS and Linux.

The idea is pretty simple:

Don't just ask an AI about a subject. Give it a place to investigate the subject with you.

GitHub: github.com/ronak-create/burrow

Would be curious to see what people would use an infinite AI research canvas for — academic research, reverse engineering, investigations, literature reviews, product research, or something completely different?

Built a from-scratch inference engine for DeepSeek-V4 in plain C99 — no PyTorch, no Python runtime dependency for inference, Apache-2.0 licensed. Streams weights off NVMe instead of requiring the full checkpoint in RAM, so it runs the 284B-parameter Flash model on a laptop with as little as 3.2GB RAM (1.6–1.7s/token with GPU offload at 16GB budget).

Why post this here specifically:

Fluent output from an LLM engine is weak evidence it's actually correct — a subtly broken implementation can still produce confident, plausible text. So this is checked against a pure PyTorch reimplementation (written independently from DeepSeek's inference/model.py, not from this C code, so both can't share the same bug) at three levels: per-kernel (14 kernels, 5e-7 tolerance), per-block, and whole-model end to end (2.9e-6, identical argmax at every position). CPU paths (scalar/OpenMP/AVX2) are enforced bit-exact via a fixed accumulator tree, checked at runtime, not just in tests.

What's included:

• Full build + test suite (make test runs 20 gates, 21 with a real checkpoint)
• Benchmark tools for matmul bandwidth, GPU contention, and cache behavior
• Honest "what didn't work" section — SIMD approaches tried and abandoned, with the actual numbers

What's not there yet: a tool-calling driver loop (the model emits the tool-call format, but there's no orchestration layer above the CLI), and DeepSeek-V4-Pro (~671B scale) is gated/planned but never actually run — needs ~865GB of checkpoint I don't have.

Repo: https://github.com/ronak-create/deepseek-v4-in-c

Open to contributions, especially around prefill batching (currently one token at a time — README has the math on why that's the next big perf unlock) and the tool-calling loop.

Song: Honorable | Artist & Songwriters: New Kingston (from the album Kingston City)

This video was edited by FableCut itself

I posted as "the project file is the interface" and the developer loved it, i got 98 points on showhn post and got 200+ stars withing 5 hours of posting!!

Repo:- FableCut

been building this for a few weeks. FableCut is a Premiere-style editor that runs in your browser, zero npm dependencies, starts with one node server.js.

the twist: the whole timeline (clips, tracks, keyframes, captions, transitions) lives in a single project.json. so any AI agent or script that can write JSON can edit video. the open browser UI hot reloads in ~150ms when the file changes, and a revision counter means you can drag clips around while the agent is mid-task without either of you clobbering the other.

the video is a real session: i gave claude code a folder of clips + a song and said "edit a reel from these assets". it probed the footage, planned the cut, and wrote the whole edit as one JSON write. the porsche reel at the end is its untouched output. the demo video itself was also edited in fablecut, felt wrong to use anything else.

it made the front page of HN this week and the thread gave me half my roadmap (client-side export via webcodecs, hosted demo mode, auto-captions example - all open issues now).

repo: https://github.com/ronak-create/FableCut (MIT)

music in the demo: Digital Lemonade — Kevin MacLeod (incompetech.com), CC BY 4.0

would genuinely love feedback, especially from anyone who edits video for real — what would you trust an agent to do, and what would you never let it touch?