Sorot

Drop in a 2-hour podcast. Get back the 60 seconds people will actually watch. ✂️🔥

Sorot (Indonesian for spotlight) turns long YouTube or local videos into vertical 9:16 clips — transcribed, scored, framed on the speaker, captioned word by word, with a ready-to-paste title. Built for Indonesian, runs 100% locally. No uploads, no subscriptions, no watermark. 🏠

📺 video  →  🎙️ Whisper  →  🧠 scoring (+ optional LLM)  →  📱 9:16 render  →  💬 karaoke captions  →  🚀 post-ready clips

✨ What it does

🚀 Install

Ready-made images on ghcr.io/raufimusaddiq/sorot, published per release — no 10-minute build. 📦 :latest = CPU (smaller) · :latest-cuda = NVIDIA GPU. The installers pick for you.

Then open 🌐 http://localhost:8080/studio (UI + API on one port).

🪟 Windows — Docker Desktop

Paste into PowerShell — no git needed:

powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/raufimusaddiq/sorot/master/scripts/install.ps1 | iex"

Installs into %LOCALAPPDATA%\Sorot, gets Docker Desktop via winget if missing (start it once, re-run), pulls the right image, starts the app and opens the studio. 🎮 GPU needs only the normal NVIDIA driver; if Docker can't use it, it falls back to CPU. Sorot / Stop Sorot land in the Start menu. Re-run to update. 🔄

From a clone: .\scripts\install.ps1. Day to day:

Running .ps1 by hand needs Set-ExecutionPolicy -Scope CurrentUser RemoteSigned once.

🪟 Windows — native (no Docker)

Bun, Python and ffmpeg straight on Windows — no Docker, no WSL:

powershell -ExecutionPolicy Bypass -c "& ([scriptblock]::Create((irm https://raw.githubusercontent.com/raufimusaddiq/sorot/master/scripts/install.ps1))) -Mode native"

winget brings ffmpeg + Python 3.12, Bun goes in .tools\bun, then the venv (+ cuBLAS/cuDNN wheels on NVIDIA — no CUDA toolkit), UI build and Whisper model. Starts at logon. ⚙️ Settings .env.native · 📜 logs data\logs\sorot.log. New and untested on real Windows — feedback welcome. 🙏

Options (both modes): -Port 8090 · -Cpu · -Dir D:\Sorot · -Build · -SkipModel · -NoStart · -Uninstall [-Purge].

🐧 Linux — installer

Debian / Ubuntu and friends:

git clone https://github.com/raufimusaddiq/sorot.git && cd sorot
scripts/install.sh                 # 🐳 Docker (recommended) — pulls the image
scripts/install.sh --mode native   # 🧩 or Bun + Python + systemd

Installs what's missing (Docker, NVIDIA Container Toolkit — or ffmpeg, Python, Bun), picks GPU or CPU, survives reboots, adds the sorot CLI. Re-run to update · --build to build locally · --uninstall to remove. 👉 docs/linux-install.md

🐳 Docker — any OS

Compose v2.24+ (Linux GPU also needs the Container Toolkit):

git clone https://github.com/raufimusaddiq/sorot.git && cd sorot
docker compose --env-file .env.docker up -d backend      # CPU image

🎮 NVIDIA GPU? Add a docker-compose.override.yml (gitignored) first:

services:
  backend:
    restart: unless-stopped
    image: ghcr.io/raufimusaddiq/sorot:${SOROT_VERSION:-latest}-cuda
    build:
      args:
        BASE_IMAGE: nvidia/cuda:12.6.3-cudnn-runtime-ubuntu24.04   # for --build
    environment:
      WHISPER_DEVICE: cuda
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

📜 … logs -f backend · ⏹️ … down · ⬇️ … pull backend && … up -d backend · 🔨 … up -d --build backend. Settings in .env.docker; SOROT_VERSION pins a release (default latest).

🧠 The Whisper model (~1.6 GB) isn't in the image — it downloads once into the hf-cache volume and survives updates. Installers fetch it up front; by hand: docker compose --env-file .env.docker run --rm --entrypoint /app/ai-pipeline/.venv/bin/python3 backend -c "from faster_whisper import WhisperModel; WhisperModel('large-v3-turbo', device='cpu', compute_type='int8')"

Images are linux/amd64 — on Apple Silicon use Homebrew.

🍎 macOS — Homebrew

CPU only, manual, untested on a Mac — feedback welcome:

brew install oven-sh/bun/bun ffmpeg python@3.12
git clone https://github.com/raufimusaddiq/sorot.git && cd sorot
python3.12 -m venv ai-pipeline/.venv
ai-pipeline/.venv/bin/pip install -r ai-pipeline/requirements.txt
bun install && bun run build                     # UI → frontend/out
cat > backend/.env <<EOF
PYTHON_PATH=$PWD/ai-pipeline/.venv/bin/python3
PIPELINE_DIR=$PWD/ai-pipeline
YTDLP_PATH=$PWD/ai-pipeline/.venv/bin/yt-dlp
DATA_DIR=$PWD/data
STATIC_DIR=$PWD/frontend/out
WHISPER_DEVICE=cpu
WHISPER_MODEL=small
EOF
cd backend && bun run src/index.ts               # 🌐 http://localhost:8080

Any .env.docker option works in backend/.env. 🔄 Update: git pull, re-run pip install and bun install && bun run build, restart.

⌨️ CLI only — sorot anywhere

One binary that drives any Sorot over HTTP — e.g. your laptop → a GPU box. The Linux installer adds it; elsewhere:

cd cli && bun run build                          # → cli/dist/sorot (.exe on Windows)
# no Bun? cross-compile (bun-linux-x64|-arm64, bun-darwin-arm64|-x64, bun-windows-x64):
docker run --rm -v "$PWD/cli:/cli" -w /cli oven/bun:1.3.12 \
  bun build --compile --minify --target=bun-darwin-arm64 src/main.ts --outfile dist/sorot

Put it on PATH, then SOROT_URL=http://gpu-box:8080 sorot health. 📖 docs/cli.md

💻 No graphics card? No problem

Everything runs on the CPU — installers switch automatically (--cpu / -Cpu to force). Only NVIDIA GPUs accelerate (CUDA + NVENC).

🧠 On a CPU, Sorot renders only the 10 best clips per video — the rest are listed with scores and titles, one Render click away (MAX_RENDER_CLIPS). It also runs one video at a time, shows how far Whisper has got (Transcribing 37%), and a retry reuses the transcript instead of running Whisper again. Importing a time range copies that section instead of re-encoding it. A GPU renders every PRIMARY/BACKUP clip.

⏱️ 12-core CPU: a 1-hour video transcribed in ~30 min (large-v3-turbo) or ~15 min (small), plus ~25 min to render 45 clips. RTX 4060: a 54-min video took ~22 min end to end. Both were measured before the CPU speed-ups (one-pass render with captions, veryfast, Whisper on every core) — in a 4-core benchmark a 30 s clip went from 168 s to 46 s, so expect much less now. On 4 cores, a 40 s clip with face framing and captions renders in ~22 s; scoring an hour of video takes ~35 s. 🐢 Whisper is the slow part: try WHISPER_BEAM_SIZE=1 or WHISPER_MODEL=small, or YOUTUBE_CAPTIONS=true to skip it when a video has uploaded captions.

🎞️ Making clips

1. 🌐 Open http://localhost:8080/studio
2. 🔗 Paste a YouTube URL or pick a file → Import & Process (⚙️ Options: caption style, framing, silence trim, hook first, music, or just 13:25 → 25:00)
3. ⏳ Watch the 9 stages tick by
4. 🏆 Filter PRIMARY / BACKUP / SKIP, preview (on a CPU, Render the clips past the top 10)
5. 📋 Copy the title + description, download the .mp4
6. ✏️ Edit timing or a word → re-render that clip
7. 📊 Post, then log the results (FB); after 5+, Retrain in Learning

⌨️ sorot — the command line

sorot import "https://youtu.be/…" --style hormozi --trim --hook   # 🎬 import, wait, list clips
sorot import ~/Videos/talk.mp4 --from 13:25 --to 25:00            # ✂️ one section of a file
sorot clips <video> --tier PRIMARY                                # 🏆 the best clips
sorot download --video <video> -o ~/clips                         # 💾 grab the .mp4s
sorot rerender <clip> --start 61 --end 100                        # ✏️ fix one clip's timing
sorot discover auto "podcast bisnis"                              # ✨ agent finds source videos
sorot discover search "podcast indonesia"                         # 🔎 or search yourself
sorot connect setup                                               # 🔌 Jev, LLM, Tebar: asks, saves, tests
sorot publish <clip>                                              # 🚀 pick accounts, check copy, post
sorot posts <clip> · sorot sync                                   # 📊 post status · numbers into learning
sorot up | down | logs -f | doctor                                # 🛠️ run the app

--json for scripts, --url / SOROT_URL for another machine. 📖 docs/cli.md · 🔌 Recipes (batch import, watched folders, timers, Python): docs/integration.md

🧠 How it works

YouTube URL / file ──► Bun API ──► 9-stage pipeline
                     1. 📥 Import        yt-dlp (or a time range)
                     2. 🔊 Audio         ffmpeg
                     3. 🎙️ Transcribe    faster-whisper, word timestamps
                     4. ✂️ Segment       gap-based candidates + Jev-judged sentence windows (or the LLM director)
                     5. 🧠 Score         13 signals + Jev (or LLM review), quality gate, hook + title
                     6. 📱 Render 9:16   crop, silence trim, hook, captions + music — one encode
                     7. 💬 Captions      (re-burns only clips rendered the old way)
                     8. 🔁 Variations    zoom / crop presets
                     9. 📊 Analytics     distribution + recommendations
              Web UI · sorot · scripts ◄── HTTP API (port 8080)

🏅 Scoring

13 weighted signals (ai-pipeline/weights.json, or your learned data/weights.json):

➕ sharp questions, clashes, lists, emotion, conversational tone · ➖ slow openings, silence, generic, no face 🏆 PRIMARY ≥ 0.80 · 🥈 BACKUP ≥ 0.65 · 💤 SKIP < 0.65

With Jev (or else an LLM), the score is 50% formula + 50% its judgement; if it's unreachable, the formula decides. Each clip records who scored it and why.

🎬 LLM director, 🚦 quality gate, 🚀 publishing

• 🎬 Director — Jev first: code proposes a window at every sentence start, Jev judges them all and keeps the best 40 next to the rule windows, scores every candidate, and picks the hook line and a quoted title for the clips that render. On 10 min of a real transcript, segmenting + scoring took ~10 s with Jev (about $0.01 at TypeSafe's listed price) vs 6.5-9 min with a reasoning LLM as director. Without Jev (or JEV_DIRECTOR=false), the LLM director reads the video, writes a brief and picks moments + hooks. Either way, overlaps keep the better clip; give a direction at import to steer it.
• 🚦 Gate before render: PASS / REVIEW (content risk — you decide) / FAIL (held back, renderable on request). Jev when connected, text rules otherwise. Measure the questions with bun run jev-eval.
• 🤖 The LLM is for writing: post copy per platform, and the ✨ auto-discover agent that searches for new videos.
• 🚀 Publish (Tebar), in the studio or sorot publish: pick accounts (grouped by Tebar workspace) → LLM copy per platform → you edit and choose (TikTok privacy or send as a draft, YouTube "made for kids") → post or schedule → retry failed accounts or cancel a scheduled post → metrics sync every 6 h into learning.

👉 docs/creative-loop.md — the design, the questions and their sources.

🔬 What's actually "AI" here?

Whisper is a neural network, and so is the LLM if you add one. Faces use classic ML (Haar cascades). The clip score is a hand-tuned formula — fast, explainable, offline — not a trained model; LightGBM can take over after 200+ real results. 👉 docs/ai-audit.md

📈 Learning from your posts

📤 Views / likes / comments / shares / saves — synced from Tebar, or logged by hand → 🧮 a time-normalised viral score → 🔄 after 5+, Retrain Weights (Pearson + EMA, α = 0.3) → ✅ next import uses them. Learned weights live in data/weights.json and survive updates.

🔎 Discovery

Finds long-form sources (podcasts, talk shows, stand-up, VODs), not other people's clips: re-clips filtered, 30–180 min favoured, last 90 days by default.

• ✨ Auto-discover — the LLM agent reads what Indonesians talk about now, searches YouTube, reads captions, picks with reasons. No LLM? Random anchor queries, best scores, ≤ 2 per channel.
• 🧾 Whole-video scoring in 45 s caption windows — strong moments, best timestamps, talk ratio.
• 🗣️ Reasons like "3 strong moments, best at 4:38".
• 📡 Channel crawler profiles sources and rejects clip farms; queue the best in one go.

📝 Titles & descriptions

Every clip gets a title (hook + hashtags, ≤ 100 chars) and a description (hook + summary + 7 hashtags + CTA) — one click to copy.

⚙️ Configuration

.env.docker (Docker) · /etc/sorot/sorot.env (native Linux) · .env.native (native Windows) · .env (dev overrides). Most options can also be set per import in the UI or with sorot import flags.

🔌 LLM, Jev and Tebar can also be set in the app (Settings in the dock) or with sorot connect — saved in the database, they win over these varia