What does screenstudio-alt do?

screenstudio-alt polishes screen recordings into shareable demos with auto-zoom, idle speed-up, and vertical/social output without requiring a paid Screen Studio license. It uses an event logger to capture cursor position, clicks, and keys during recording, then applies post-production effects like auto-zoom on click clusters, keystroke overlays, and a smoothed synthetic cursor.

Do I need to use the event logger to get idle speed-up?

No, the `--speedup` flag in `polish.py` works without an event log by using freeze-detection alone, so you can compress idle time even on existing recordings that were never captured with the event logger running.

Can I edit the zoom regions and timing after recording?

Yes, `studio.py` provides a local web UI with an NLE-style timeline where zoom regions are draggable, retimeable blocks and idle spans are edited by speed rate only, with changes rippling downstream. Export then goes through `render.py`.

What are the technical dependencies?

screenstudio-alt is built on ffmpeg and PIL rather than a hosted editor. It uses PIL-rendered PNG composites for text and cursor overlays, and `zoompan` for animated zoom, since ffmpeg's crop filter cannot safely handle per-frame expressions.

Skill

Polish screen recordings with auto-zoom and idle speed-up

Name: Screenstudio Alt
Availability: OnlineOnly
Author: connerkward

A Screen Studio alternative: capture-time input logging plus a spring-physics auto-zoom, idle speed-up, and NLE-style editing timeline.

Get skill

Works with ffmpegmacos

connerkward

Own this? Claim it

Maintainer of this project? Claim this page to edit the listing.

Spark score

out of 100

Updated last month

Version 1.0.0

Add to Favorites

Why it matters

Transform raw screen captures into polished demo videos with automatic zoom on clicks, idle-time compression, smooth cursor animations, keystroke overlays, and vertical social-media formatting-all driven by input events captured during recording.

Outcomes

What it gets done

Capture cursor, click, and keystroke events at 60Hz during screen recording for post-production effects

Compress idle segments by detecting input gaps and frozen pixels while preserving animations at 1x speed

Apply eased auto-zoom to click clusters and render smooth synthetic cursor paths with click ripples

Export both horizontal and vertical (9:16) formats with timeline-based NLE editing for zoom regions and speed adjustments

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-screenstudio-alt | bash

Overview

Screenstudio Alt

A Screen Studio alternative combining capture-time input logging with spring-physics auto-zoom, idle speed-up, and an NLE-style editing timeline for screen recordings. Use when polishing a screen recording or demo video for sharing, especially social-facing demos needing vertical output.

What it does

screenstudio-alt polishes a screen recording into a shareable demo with auto-zoom, idle speed-up, and vertical/social output, without depending on a paid Screen Studio license. It has two halves: events-log (Swift), a capture-side logger recording cursor position at 60Hz, clicks, and keys while recording is active - data that cannot be reconstructed from pixels afterward, so it must run during capture - and a post-production pass that uses that log to drive auto-zoom on click clusters, accumulating keystroke overlays, and a synthetic smoothed cursor.

When to use - and when NOT to

Use it when polishing a screen recording or demo video for sharing, especially any social-facing demo, where vertical (9:16) output is the default. polish.py's --speedup flag works without any event log at all, using freeze-detection alone, so idle-compression is usable even on an existing corpus of dailies that were never captured with the event logger running.

Inputs and outputs

render.py is the preferred renderer: a single-pass spring-physics camera (tunable --freq/--zeta) moves over the original high-resolution frames before a LANCZOS downscale, producing a crisper zoom (about 1.3x sharper) than the older ffmpeg-filter fallback, polish.py, and emitting both horizontal and 9:16 vertical at 60fps from explicit --regions [{t0,t1,z,cx,cy}]. studio.py runs a local web UI with an NLE-style fixed-ruler timeline (the bar always represents source duration, never rescaling) where zoom regions are draggable, retimeable blocks and idle spans are speed blocks edited by rate only - the source range stays locked while a rate-stretch drag on the right edge (the Final Cut/Premiere Rate Stretch pattern) changes playback speed, rippling downstream only. Export goes through render.py; the whole record-then-polish-then-emit-vertical chain is also available in one command via screencast.sh --demo.

python3 src/polish.py in.mp4 --events in.events.jsonl --speedup --zoom --vertical

Integrations

Built on ffmpeg and PIL rather than a hosted editor - a documented local gotcha is that this machine's ffmpeg lacks drawtext, so every text/cursor overlay is a PIL-rendered PNG composited with overlay, and animated zoom uses zoompan instead of scale=eval=frame+crop because ffmpeg's crop filter can't handle per-frame expressions safely across a link reinit. A make-fixture.py test rig synthesizes a fake recording plus ground-truth event log so changes can be validated before trusting real footage.

Who it's for

Anyone recording screen demos for social or documentation use who wants Screen Studio's auto-zoom, idle speed-up, and vertical export without the paid product - and who wants an editable NLE-style timeline rather than a one-shot automated pass, since pacing and framing still need human review.

Source README

When to Use

Use when polishing a screen recording / demo video for sharing, when the user mentions Screen Studio, auto-zoom, idle speed-up, or vertical/social video from a screen capture, and for any social-facing demo (vertical output is the default for those).

Source: connerkward/screenstudio-alternative-skill (MIT).

screenstudio-alt

The skill's code lives in this directory (polish.py, render.py, studio.py,
events-log.swift, test fixtures, etc.). Published publicly as
connerkward/screen-studio-alternative via the publish-skill skill.

Two components:

events-log (Swift) - capture-side input logger (cursor 60Hz, clicks, keys;
drops keys during macOS secure input). Runs ONLY while recording. Needs
Accessibility/Input Monitoring for the terminal. Auto-zoom/keys/cursor need
this data at capture time - it cannot be recovered from pixels later.
polish.py (Python, ffmpeg + PIL) - the post-production pass:

python3 src/polish.py in.mp4 --events in.events.jsonl \
  --speedup            # compress idle (input-gap ∩ frozen-pixels; animations stay 1x)
  --zoom               # eased auto-zoom on click clusters (zoompan)
  --keys               # accumulating keystroke chips (PIL overlays, no drawtext dep)
  --smooth-cursor      # synthetic eased cursor (best with sck-record --no-cursor)
  --vertical           # ALSO emit 1080x1920 following the action

--speedup works WITHOUT events (freezedetect only) - usable on the whole
existing dailies corpus.

render.py - high-quality non-destructive renderer (preferred): single-pass
spring-physics camera over the original high-res frames, LANCZOS into a smaller
target (crisp zoom, ~1.3× sharper than the ffmpeg upscale path), 60fps, H + 9:16 V.
Tunable --freq/--zeta (spring), --fps, --target-w. Takes explicit
--regions [{t0,t1,z,cx,cy}]. polish.py is the older ffmpeg-filter fallback.
studio.py [recording.mp4] - local web UI, NLE-style fixed-ruler timeline (bar =
source duration, never rescales → upstream always planted): zoom regions are draggable
blocks (move / retime edges / click to add / double-click delete); idle spans are
speed blocks with rate-only editing - source range locked, rate set via inspector
slider on select or right-edge rate-stretch drag (FCP retime / Premiere Rate
Stretch); rate changes ripple downstream only. Tunable cosine-ease ramp, default zoom,
aspect, frame styling. Always-smooth synthetic cursor + click ripple + real recorded
click sound (CC0 #735771). Export uses render.py. Free port, local. (Keystroke overlay
exists in the engine but is off by default.)

Easy path

screencast.sh --demo (screencast skill) does the whole chain: starts the event
logger, records, then polishes + emits the 9:16 vertical automatically. Vertical
is the DEFAULT for social-facing demos.

Gotchas (learned the hard way, kept here so they're not relearned)

ffmpeg CANNOT do animated scale=eval=frame → crop (link reinit wedges crop's
per-frame exprs). That's why zoom uses zoompan (no t var there - use on/FPS).
This machine's ffmpeg lacks drawtext; all text/cursor overlays are PIL-rendered
PNGs + overlay.
Test rig: make-fixture.py synthesizes a fake screen recording + ground-truth
events.jsonl - validate any change against it before trusting real footage.

Limitations

The workflow assumes FFmpeg plus the companion scripts are available locally; it is not a hosted video editor.
Polished cursor, click, and keystroke effects depend on event logs captured during recording; missing logs limit what can be reconstructed.
Auto-zoom and idle speed-up still need human review for pacing, framing, and platform-specific taste.

FAQ

Common questions

Discussion