AURAX

Desktop editor that turns a music track and a folder of clips into a beat-synchronized short edit, automatically.

Download · How it works · Run from source · Demo notes

AURAX is an Electron application for making "aura edits": fast, rhythmic, character-focused short videos cut to music. You import videos and images, import a song, press GENERATE AURA and get a complete edit with cuts on beats, a burst on the drop, punch zooms, shakes, flashes and transitions placed by the beat grid. A light manual editor lets you fix things afterwards, and the export renders the same frames the preview shows.

Everything runs locally. No accounts, no uploads.

Demo

The screenshot above and the video below were produced by AURAX from 21 Jujutsu Kaisen animation cuts discovered on Sakugabooru and a 15 second track. The application analyzed the music, scanned the clips and generated the whole timeline from the AURA preset and seed 614997481. Nothing was placed by hand.

aurax-anime-demo-compressed.mp4

Watch the generated edit (MP4, 16 s, 13 MB)

What the generator did with this track:

Music analysis	Edit
101.4 BPM, 28 beats, 7 bars	22 clips over 15.96 s
Intro (0 to 5.9 s) at 40 percent energy	Two bar-long shots on the intro downbeats, then a one-bar shot
Drop detected on the downbeat at 7.02 s	A shot with a speed ramp into the drop, then a four-cut burst with flash, punch zoom, motion blur and RGB split
Chorus at 92 percent energy	One cut per beat (0.59 s) with punch zooms and shakes, RGB split on impacts, flash and spin cuts on accents

demo/metadata/demo-edit.json lists every cut with its source post, effects and transition, and demo/README.md explains how to reproduce the demo with the scripts in scripts/demo/.

The animation belongs to its rights holders (Jujutsu Kaisen by Gege Akutami, Shueisha, MAPPA). The clips come from Sakugabooru and are credited post by post in demo/metadata/anime-source.json. They are used only to demonstrate the editor and are not redistributed by this repository.

How the auto-edit works

1. Music analysis. FFmpeg decodes the track to mono PCM. A short-time Fourier transform produces onset strength, bass onset, loudness and brightness envelopes. Tempo comes from the autocorrelation of the onset envelope with a log-normal prior, beats are tracked with dynamic programming, the downbeat phase is the one whose beats carry the most bass and loudness change. Sections (intro, build, drop, chorus, break, outro) come from a slow energy envelope. Drops are energy jumps into a high-energy section, including jumps at the end of a build, placed on the downbeat that carries the hit.
2. Media analysis. Every clip is probed and scanned once for scene changes and black stretches (fades, gaps, leaders), so the composer can start shots after a cut and never inside black.
3. Cut plan. The planner walks the beat grid inside the music window. Section energy, beat strength and the preset decide whether a beat cuts, holds or subdivides. The drop becomes a burst of four cuts, the beat before it is held for a speed ramp, calm sections hold longer shots.
4. Composition. Each segment picks an asset by weighted random choice (tags, recency, usage balance), a source range that avoids reuse and black frames, an optional close-up framing, an effect stack scaled by beat strength and preset intensity, and a transition. Every random decision uses a seeded generator, so the same inputs, preset, bias and seed give the same timeline.
5. Render. evaluateFrame turns the project and a time into what is on screen. The preview paints it on a canvas in real time with the music as the master clock. The exporter renders every frame through the same function at output resolution and streams RGBA into FFmpeg (H.264 or H.265 plus AAC).

Features

• Import videos and images by dialog or drag and drop, with thumbnails, ffprobe metadata, scene-change and black-frame scans.
• Music analysis: BPM, beats, downbeats, bars, energy, bass, onset strength, sections and drops. A second "beat source" file (an instrumental or a drum stem) can drive the cuts while the main track plays.
• Beat grid on the timeline with typed markers (minor, major, bar, downbeat, impact, drop) and a music window strip to pick which part of a long song to edit.
• Presets: AURA, BADASS, AGGRESSIVE, CINEMATIC, ROCK, PHONK, DARK, HYPE, GLITCH, CHAOTIC, MINIMAL, plus bias sliders (aggressive, cinematic, chaotic, clean, transitions, face shots, close-ups, flashes).
• Effects: punch zoom, push zoom, image motion, shake, flash, motion blur, RGB split, glitch, color punch, color grade, speed ramp, strobe. Transitions: hard cut, flash cut, black flash, zoom cut, whip pan, glitch cut, spin cut.
• Manual editing: select, multi-select, move, trim, split, duplicate, delete, ripple, snap to beats, effect stack and transition editing, undo and redo, 30 or so keyboard shortcuts.
• Canvas presets for TikTok, Reels, Shorts, X, square and landscape, or any custom even size. Export to MP4 with per-platform bitrate presets.
• Project save and load as JSON.

Not implemented yet: face detection and subject tracking, background removal, typography, GPU shader effects, WebCodecs decoding. See docs/superpowers/specs/2026-09-24-aurax-design.md for the roadmap.

Install

Packaged builds for Windows (NSIS installer) and Linux (AppImage and deb) are on the releases page. AURAX needs FFmpeg and ffprobe on the PATH, or pointed to with the AURAX_FFMPEG and AURAX_FFPROBE environment variables. FFmpeg 6 or newer works; the app is developed against FFmpeg 9.

Run from source

Requirements: Node 20 or newer (developed on Node 24), pnpm, FFmpeg.

pnpm install
pnpm dev

Other scripts:

pnpm test          # vitest: DSP, beat tracking, drop detection, composer, frame evaluation
pnpm typecheck     # tsc for main, preload, core and renderer
pnpm build         # electron-vite production build into out/
pnpm package:linux # electron-builder: AppImage and deb
pnpm package:win   # electron-builder: NSIS installer
pnpm dev:debug     # dev with the Chrome DevTools Protocol on port 9333
pnpm e2e           # drives a dev:debug instance: import, analyze, generate, export, probe the MP4

The end-to-end script expects synthetic assets in test-assets/generated/. The commands that create them are in the design spec.

Workflow

1. Import videos and images. Tag assets from the card hover bar: favorite, primary, face, impact, b-roll, transition. Tags change how often and where the composer uses them.
2. Import music. Analysis starts automatically and is cached by file identity. Use the music window strip at the top of the timeline to choose which part of a long song to edit, or "Use full track" for short songs.
3. Pick a preset, move the bias sliders if you want, and press GENERATE AURA. Randomize draws a new seed, Regenerate keeps the seed after you change the preset or the sliders.
4. Press Space to preview. Adjust clips in the timeline or the Clip tab if needed.
5. Export from the Export tab.

Keyboard: Space, K and L control playback. Arrows step one frame, Shift steps one second, Ctrl+arrows jump between beats, Alt+arrows jump between clip edges, Home and End go to the start and end. Click selects, Shift-click selects a range, Ctrl-click toggles, dragging on empty space draws a marquee. Ctrl+A selects everything in the focused section, Escape clears the selection, Delete removes selected clips or assets. S or Ctrl+K split at the playhead, Ctrl+C, Ctrl+X and Ctrl+V copy, cut and paste clips, Ctrl+D duplicates, F favorites the selected assets. Ctrl+Z and Ctrl+Y undo and redo, Ctrl+G generates, Ctrl+R randomizes, Ctrl+I and Ctrl+M import media and music, Ctrl+S, Ctrl+O, Ctrl+N and Ctrl+E save, open, create and export. Ctrl+wheel zooms the timeline.

Architecture

src/
  shared/      types and the IPC contract shared by main and renderer
  core/        pure TypeScript, no Electron or DOM dependencies
    audio/     FFT, onset detection, tempo, beat tracking, downbeats, sections, drops, beat grid
    effects/   EffectRegistry and the built-in effects
    transitions/ TransitionRegistry and the built-in transitions
    presets/   PresetRegistry with the editing modes
    compose/   cut planner and composer (GENERATE AURA)
    render/    FrameState and evaluateFrame: project + time -> what to draw
    project/   project creation and pure timeline operations
    random/    seeded PRNG and value noise
  main/        Electron main: window, media protocol, IPC, services, workers, export session
  preload/     contextBridge API (window.aurax)
  renderer/    React UI, zustand store, preview engine, canvas renderer, exporter
scripts/
  e2e.mjs      end-to-end smoke test over the DevTools protocol
  demo/        fetch-sakugabooru.mjs and build-demo.mjs, the scripts behind the demo above

Design rules the code follows:

• The renderer never touches video processing directly. evaluateFrame in src/core/render decides what is on screen for a given time, CanvasRenderer only paints it, and the exporter reuses both. Preview and export cannot disagree.
• Every random decision goes through Prng seeded from the project seed. Same project and seed, same timeline and same render.
• Effects and transitions are registry entries with typed parameters. Adding one means adding a definition; the inspector, the composer and the renderer pick it up.
• Heavy work lives outside the renderer: ffprobe, thumbnails, scene and black scans and encoding run in the main process, music analysis runs in a worker thread. Results are cached under the app's user data directory keyed by path, size and modification time.
• Local media is served through the aurax-media:// protocol with HTTP Range support and CORS headers, so video elements can seek and canvases stay untainted.

License

MIT. The demo footage and music are third-party material, see the demo section above and demo/README.md.