Smartie

Smartie is a source-available, noncommercial smart screen recorder for polished demo videos, with native telemetry pipelines and packaged desktop builds for Linux and Windows. It records a selected screen or window through Electron with a hybrid smart pipeline by default: capture stays native and low-latency during the take, then the smart zoom, cursor polish, overlays, and framing effects are baked into the saved video after recording.

Current Features

• Screen and window source picker with live thumbnails.
• Hybrid Smartie pipeline that records native video first and post-renders smart effects into the saved file.
• Native smooth recording pipeline for direct desktop capture when no baked effects are needed.
• Optional canvas-based live smart-effects pipeline for fully real-time baked effects.
• Adaptive performance governor with Auto, Potato saver, Ultra smooth, Balanced, and Max quality profiles.
• Disk-backed recording sessions that stream MediaRecorder chunks to the main process instead of holding the whole take in renderer memory.
• Smart Director v2 auto zoom with telemetry capture, cue scoring, offline camera-plan compilation, render QA, and smooth keyframed playback.
• Native telemetry core with Wayland-aware quality grading, a compositor-adapter socket, Windows User32 helper support, optional stdio helper support, and per-take native telemetry artifacts.
• One-click/CLI GNOME Shell telemetry adapter install flow plus packaged KWin telemetry adapter assets.
• Bundled Windows native telemetry helper for cursor, clicks, foreground window bounds, and privacy-aware keyboard intent.
• Director failsafe planning for Wayland/window-source recordings where cursor telemetry is unavailable or stuck.
• Smart focus modes for Smart Director, cursor follow, motion-aware targeting, click-to-lock focus, and forced wide shot.
• Director style presets for subtle, balanced, or cinematic camera plans.
• Editable Director Plan controls for hiding shots, adjusting zoom intensity, and changing shot duration after a take.
• Separate telemetry timelines for cursor, click, keyboard, motion, accessibility context, native/compositor diagnostics, proxy preview metadata, and render QA.
• Vector cursor/highlight rendering that follows the compiled camera transform instead of being tied to raw captured pixels.
• Master Smart Features toggle plus individual toggles for:
  • Auto zoom
  • Cursor spotlight
  • Cursor trail
  • Motion focus
  • Keyboard overlay
  • Rendered take title overlays
  • Presenter cue overlays
  • Click/moment pulse
  • Automatic smart chapter markers
  • Idle wide shot
  • Privacy blur
• Microphone capture support.
• Live mic level meter with gain control, noise gate, and recording-safe mute.
• Microphone and camera device selectors with refresh support.
• Optional mirrored webcam bubble with selectable corner placement.
• Optional hide-while-recording mode to keep Smartie out of full-screen takes.
• Auto-save mode with a selectable output folder for repeated takes.
• Recent takes list with quick reveal actions.
• Chapter markers with a shortcut and automatic smart moments for timeline metadata.
• JSON sidecar metadata next to every saved video with markers and smart settings.
• Smartie project sidecar next to every saved video with recording, manifest, metadata, attention timeline, and editable camera plan files.
• WebVTT chapter sidecars for marker import into players and editors.
• PNG snapshot capture from the polished recording canvas.
• Take title naming with optional rendered title card and lower-third overlay.
• Presenter cue text with optional rendered top or bottom prompt overlay.
• Landscape 16:9, wide 16:10, square 1:1, and vertical 9:16 output layouts for demo, social, and mobile-ready exports.
• Rendered privacy blur region for masking sensitive UI during demos.
• Live capture health telemetry with FPS and dropped-frame estimates.
• Pause/resume, discard, and elapsed-time tracking that excludes pauses.
• Persistent capture and smart-framing preferences.
• Global recorder shortcuts with Wayland portal support where available.
• Low-latency Smartie hybrid engine, native recording engine, live smart-effects engine, adaptive optimization presets, quality presets, frame-rate control, smart-effects layout control, countdown, elapsed timer, WebM export, and optional bundled-FFmpeg MP4 copy.
• Linux desktop support through Electron desktop capture APIs and GNOME/KWin telemetry adapters.
• Windows desktop package support through Electron desktop capture and bundled User32 native telemetry.

License

Smartie is licensed under the PolyForm Noncommercial License 1.0.0. Commercial use is not permitted without a separate commercial license from the copyright holder. This is source-available software with a noncommercial restriction, not an OSI-approved open-source license.

Requirements

• Node.js 22 or newer.
• npm 9 or newer.
• Linux desktop session with screen capture permission available to Electron, or Windows 10/11 for the packaged Windows build.

Install

npm install

Run

npm start

The development launcher passes Electron --no-sandbox so it can run from mounted Linux drives where Chromium's setuid sandbox helper cannot be made root-owned.

Global Shortcuts

• Ctrl+Alt+R: start or stop recording.
• Ctrl+Alt+P: pause or resume recording.
• Ctrl+Alt+X: discard the active recording.
• Ctrl+Alt+S: toggle Smart Stack features.
• Ctrl+Alt+M: mute or unmute microphone.
• Ctrl+Alt+F: lock or release smart focus.
• Ctrl+Alt+K: drop a chapter marker.
• Ctrl+Alt+J: save a PNG snapshot.
• Ctrl+Alt+H: show or hide Smartie.

On some desktop environments a shortcut can fail to register if another app or the OS already owns it.

Verify

npm run check
npm run smoke
npm run doctor
npm run telemetry:adapter -- status
npm run eval:telemetry -- /path/to/take.smartie-project
npm run eval:director -- /path/to/take.smartie-project

Smartie Project

Each saved take writes a Smartie project directory beside the WebM:

smartie-my-take.webm
smartie-my-take.smartie.json
smartie-my-take.chapters.vtt
smartie-my-take.smartie-project/
  manifest.json
  recording.webm
  attention.timeline.json
  cursor.timeline.json
  click.timeline.json
  keyboard.timeline.json
  motion.timeline.json
  accessibility.timeline.json
  native.timeline.json
  proxy.timeline.json
  camera.plan.json
  render.qa.json
  proxy-preview.jpg
  recording.smartie.json

The attention timeline stores high-level cues. The separate telemetry timelines store source cursor, click, keyboard, motion, semantic/accessibility context, native/compositor telemetry, proxy preview metadata, and render QA. The camera plan stores compiled smart zoom shots, keyframes, QA warnings, and editable segment metadata so Smartie can edit the director plan without changing the capture format.

Performance Architecture

Smartie records through an adaptive telemetry-first pipeline. The Auto profile inspects CPU cores, memory, platform, and desktop session, then chooses the lightest profile that should keep capture smooth. Potato saver caps capture resolution, FPS, bitrate, preview refresh, motion scanning, webcam capture, and telemetry density. If the live canvas path starts dropping frames, the governor demotes expensive work during the take.

The default Smartie hybrid engine keeps capture native and streams chunks to a temporary main-process recording session on disk. Smart zoom, vector cursor polish, overlays, and camera-plan rendering happen after stop, so weaker systems do not pay that cost while recording. Live smart effects remain available, but Auto and Potato saver move live canvas recording to hybrid when needed.

Smartie also evaluates telemetry quality before compiling the camera plan. Each recording starts a native telemetry session and writes native.timeline.json with the active telemetry tier: precision, native-pointer, portal-ready, x11-native, or electron-fallback. If Wayland or a window-source capture reports unusable all-zero cursor data, the Director falls back to native pointer snapshots when available, then visual motion telemetry, and finally conservative failsafe focus shots instead of rendering a long wide-only take.

On Linux/X11, semantic context can include active window and pointer telemetry through xdotool when available. On Wayland, Smartie opens $XDG_RUNTIME_DIR/smartie-telemetry.sock during recording so trusted compositor adapters can stream cursor, focus, and window geometry without loading the capture loop. The bundled GNOME Shell adapter lives under native/linux/gnome-shell/smartie-telemetry@akmessi and can be installed from the app or with npm run telemetry:adapter -- install. KWin adapter package assets live under native/linux/kwin/smartie-telemetry; KWin runtime streaming still needs a small D-Bus/log bridge helper. Production native helpers can be attached with SMARTIE_TELEMETRY_HELPER=/path/to/helper. On GNOME Wayland, a freshly installed local extension may show as pending until the next login.

On Windows, Smartie automatically starts the bundled native/windows/smartie-telemetry-helper.ps1 helper while recording. The helper uses Win32/User32 APIs through PowerShell to stream pointer movement, mouse click transitions, foreground window metadata, and privacy-aware keyboard intent events into native.timeline.json.

Package

npm run package:linux
npm run package:win

Folder packages are written to dist/ and are used for quick smoke checks.

Installer-style release artifacts are built with:

npm run release:linux
npm run release:win

Release artifacts are written to release/. Linux release builds produce an AppImage. Windows release builds produce an NSIS installer. GitHub tag builds publish release artifacts with SHA256 checksums.

Build release:win on Windows, or on Linux with Wine installed. The GitHub release workflow builds the Windows installer on windows-latest.

MP4 export uses bundled FFmpeg when the package is built on the target platform, and falls back to a system ffmpeg binary on PATH when a cross-built package does not contain a runnable FFmpeg.

Release Checklist

Before publishing a release:

npm ci
npm run check
npm run smoke
npm audit --audit-level=high
npm run doctor
npm run package:linux
dist/Smartie-linux-x64/Smartie --no-sandbox --smoke-test

Windows packaging and native telemetry must also be verified on Windows:

npm ci
npm run check
npm run doctor
npm run package:win
npm run release:win

Notes

Smartie always writes the primary recording as WebM and can also create a bundled-FFmpeg MP4 copy. Use the default Smartie hybrid engine for smooth capture with baked smart zoom and overlays. Use Native smooth only for raw desktop capture without baked smart effects. Use Live smart effects when effects must be rendered during recording instead of after stop.