Skip to content

v0.1.5

Choose a tag to compare

@github-actions github-actions released this 18 Nov 05:04
· 33 commits to main since this release
a5dc90b

Added

  • Typography: font-kerning: normal applies the font's pair kerning (GPOS kern pair adjustments or
    the legacy kern table; on the embedded Roboto it matches Chromium's shaping on every tested pair),
    including across the letters of data-hf-split="chars". font-style: italic|oblique uses an
    installed italic face or slants the upright one by 14 degrees around the baseline, as browsers do
    (generic families always slant the embedded Roboto, so they match on every machine);
    <em> and <i> are italic, as elements and as inline runs. The default font-kerning: auto does
    not kern, so existing layouts are unchanged. See examples/typography.html.

  • Multi-line kinetic text: data-hf-split accepts <br>; each line becomes a row that follows the
    element's text-align, and the stagger continues across lines.

  • Render progress: render redraws a progress line with throughput and ETA on an interactive stderr;
    --progress json writes JSON lines (done, total, fraction, fps, elapsedMs, etaMs) and
    --progress off disables it. aether_render sends MCP notifications/progress when the request
    carries _meta.progressToken. The library exposes ProgressObserver, ProgressUpdate,
    encode_native_with_progress, and render_part_with_progress. Progress never changes the output.

  • Distributed rendering: render --output part.aseg --segments A..B encodes a range of one-second
    segments into a part file, and render --output video.mp4 --parts a.aseg,... assembles parts (any
    order, checked for full coverage and matching settings) with the composition's audio, producing the MP4
    a single render writes. inspect --fps N prints the segment count. The library exposes render_part,
    assemble_parts, and segment_count. render --frames 0,45,90 with {frame} in the PNG name writes
    several stills from one process. encode.rs is now encode/ (segments.rs, parts.rs).

  • Inline rich text: <span>, <strong>, <b>, and <code> inside an element with its own text become
    styled runs (color, family, weight, letter spacing, fill, stroke, gradient) that wrap and align together.
    -webkit-text-stroke (stroked from the font outlines), -webkit-text-fill-color, and
    background-clip: text gradient text. Plain text renders byte-identically. See examples/rich-text.html.

  • data-hf-draw on inline <svg>: strokes draw themselves along their measured length, staggered in
    document order. data-hf-motion-path: any element travels along SVG path data (arcs included), with
    optional -rotate="auto". A new vector module measures paths. See examples/vector-motion.html.

  • clip-path with inset(), circle(), ellipse(), and polygon() (px or %), drawn with exact
    antialiased coverage and animated through clipPath in data-hf-keyframes; mask-image with a linear
    or radial gradient. Both apply after the element's filter. See examples/clip-mask.html.

  • Scene transitions dip-to-black, dip-to-white, flash, blur, whip-left|right|up|down, glitch,
    and rgb-split, compiled to filter tracks and new pixel-effect tracks drawn through the effect layer.
    data-hf-keyframes accepts glitch (0 to 1, a deterministic slice displacement that changes 24 times a
    second) and rgbSplit (px). See examples/light-transitions.html.

  • Audio effects on <audio> and the sound of <video>: data-hf-volume-ramp (eased gain keyframes in
    volume or db), data-hf-duck (sidechain ducking under trigger clips with look-ahead attack, hold,
    release, amount, and threshold), and data-hf-eq (up to 16 RBJ biquad bands or the voice, music-bed,
    telephone, warm, and bright presets). check/aether_check report audio.clips[].effects with the
    EQ response, ducked regions, and automation keys. Clips without effects mix byte-identically. See
    examples/audio-effects.html.

  • Variable speed on <video> and <audio>: data-hf-speed (constant rate, 0.05 to 16) and
    data-hf-speed-ramp (JSON keyframes with at, speed 0 to 16, and easing) for slow motion, fast
    forward, freezes, and speed ramps. Source time is the integral of the rate; a video's sound follows its
    picture. Audio is varispeed through an antialiased windowed-sinc reader. check reports speed,
    mediaEnd (videos), and mediaSeconds (audio clips). See examples/speed.html.

  • --quality draft|standard|high|max (CLI), "quality" in aether.json, and quality in aether_render:
    H.264 quality presets with fixed quantizers 30, 26, 22, and 18 (CRF 28, 25, 21, and 18 with
    --encoder ffmpeg). standard is the default and byte-identical to earlier exports.

  • filter color functions (brightness, contrast, saturate, grayscale, sepia, invert,
    opacity, hue-rotate) and drop-shadow(), after an optional blur(). On the root, color functions
    grade every finished frame.

  • mix-blend-mode with the separable modes (multiply, screen, overlay, darken, lighten,
    color-dodge, color-burn, hard-light, soft-light, difference, exclusion) and plus-lighter.

  • data-motion-blur on the root: deterministic shutter motion blur with data-motion-blur-shutter
    (degrees) and data-motion-blur-samples (automatic from the fastest motion when omitted).

  • Animated filters: blur, brightness, contrast, saturate, grayscale, sepia, hueRotate, and
    invert in data-hf-keyframes, and filter in CSS @keyframes. An animated blur uses a continuous
    exact-variance kernel, so it eases without steps.

  • check reports effects (motion blur settings, root grade, color filters, blend modes, and animated
    filters).

  • examples/effects.html and examples/filter-motion.html.

  • Composition variables: typed declarations in data-composition-variables (string, number, color,
    boolean, enum, image, font), bound with var(--id) in CSS, data-var-text, data-var-src, and
    data-var-if. Values come from --variables or --variables-file (render, preview, check,
    bench, inspect), "variables" in aether.json, or the variables argument of aether_check,
    aether_write, aether_snapshot, and aether_render. Unknown ids, wrong types, and out-of-range values
    are errors. check reports variables (values, defaults, uses, unused ids, removed elements). See
    examples/variables.html.

Changed

  • Determinism: MP4 output is now byte-identical for every --threads value and every distributed
    split, including compositions with cached gradients and soft shadows (premium-promo.html used to
    differ between --threads 1 and 4). An uncached draw of a whole-pixel gradient or soft shadow now
    computes the same fixed-point texels a cached tile holds, so first draws and snapshots of those
    layers can differ from 0.1.0 by one level per channel (two in a few pixels inside filtered layers).
  • Faster drawing with identical pixels: branch-free per-row kernels (render/paint/kernels.rs),
    compiled for both the baseline target and AVX2 and selected at run time, for two-stop gradients,
    radial gradient parameters, cached gradient tiles, shadow masks, and the vignette and grain pass;
    directly drawn radial gradients skip the transparent area outside their last stop. At 1080p on one
    thread: premium-promo.html −13%, glass.html −15%, drifting glows −9% to −20%, grain −54%,
    vignette −19% (median of three runs; see BENCHMARK.md). AETHER_SIMD=off forces the baseline
    kernels, for comparison.
  • <video> sources with B-frames are rejected when the composition is parsed, with a re-encode
    command, instead of failing during rendering: the bundled OpenH264 decoder cannot decode them (the
    contract used to say B-frames were supported).
  • The encoder no longer pretends to use a 24..32 quantizer range: with rate control off OpenH264 always
    encoded at quantizer 26, which is now the explicit standard default, so default exports are unchanged.
  • AAC encoding is about 12 times faster (60 s of stereo audio: 16.7 s down to 1.4 s on one core) with
    byte-identical output: the vendored oxideav-aac computes its forward MDCT with an FFT.
  • Gradient, shadow-mask, glyph, and small translucent fills avoid soft-float round and libm hypot calls in their
    per-pixel loops, cutting drawing instructions by about 11% on the promo examples with identical pixels.