Gausian Native Editor: a Rust timeline with ComfyUI wired in locally

A preview-first editor, and what that means

The README describes Gausian as a native editor focused on snappy preview, practical timeline tools, and smooth ingest and export. That ordering is a statement of priorities. Preview comes first, which is the part of a video editor that determines whether the rest is usable.

The technical claims follow from that. Preview is GPU accelerated through WGPU with YUV to RGB shaders and readback, so colour conversion happens on the GPU rather than in software on the CPU. Ingest is handled locally with FFmpeg and ffprobe probing for image, video and audio. Timeline editing, an assets panel and project persistence are all in the feature list, with persistence backed by SQLite.

Two applications are described in the architecture section. `apps/desktop` holds the egui and wgpu user interface, the timeline, assets, GPU preview, audio engine and export, along with the ComfyUI integration. `apps/comfywebview` is a separate minimal native WebView window for ComfyUI, which is a small split that suggests the WebView was factored out because it has different lifecycle requirements from the main window.

The project was last pushed on 2026-07-01, sits at 1,009 stars and 28 forks, and had 6 open issues at that point. Version 1.0.0 was published as the initial public release on 2025-11-11.

The crate split and the release build profiles

The workspace manifest lists eleven members, and each name is a description of responsibility. Alongside the two applications there are `crates/timeline` for graph, tracks and commands; `crates/project` for the SQLite database, migrations and asset, proxy and job tables; `crates/media-io` for probe and export helpers, waveforms and encoders; `crates/renderer` for the WGPU renderer and WGSL shaders; `crates/exporters` for the FCPXML, FCP7, EDL and JSON writers; `crates/plugin-host` for WASM and Python stubs; `crates/native-decoder` for VideoToolbox on macOS with an optional GStreamer backend; and `crates/cli` for import, export, convert, analyze, new and encoders.

The manifest also lists `crates/jobs`, which does not appear in the architecture description in the README. That is a small discrepancy worth noting rather than glossing over, since background job handling is exactly the sort of thing that gets added after the documentation is written.

The two build profiles are the more interesting part for anyone building from source:

[profile.dev]
# Reduce macOS file explosion and disk usage.
split-debuginfo = "packed"
# Disable incremental to avoid large per-crate caches in target/.
incremental = false

Turning off incremental compilation is normally a strange thing to do for a developer profile, and the comment explains why: it avoids large per crate caches in the target directory. The release profile keeps debug info at zero with the same packing strategy. These are the settings of someone who has hit a specific problem on a specific platform and written down the reason, which is a good sign.

ComfyUI over localhost, and only over localhost

The ComfyUI integration is the feature that distinguishes this editor from a general NLE, and it has one firm rule: local only. The README states it in three places, in the summary, in the feature list, and again in the desktop app section.

The mechanics are straightforward. ComfyUI is expected to be running locally at its default address, http://127.0.0.1:8188. You set a ComfyUI Repo Path, meaning the folder containing `main.py`, and that enables the local integrations. An optional embedded WebView opens it inside the application, and an auto import option pulls generated files out of the ComfyUI output folder into the assets panel. The embedded WebView is listed as a macOS only feature and is enabled by a Cargo feature flag rather than being default.

What is more interesting is a line that is easy to miss. The README contains an HTML comment stating that the relay section was removed because cloud connections are not available yet. That is a project telling you what it does not do yet, in the source rather than in prose. Combined with the local only restriction, it means the tool is currently a workstation application for someone whose generation pipeline already runs on the same machine, not a hosted service or a bridge to one.

Exporters, proxies and the path to an NLE

The exporter list is the most concrete evidence that this tool is built for a handoff rather than for finishing inside itself. It supports FCPXML at versions 1.9 and 1.10, FCP7 XML, EDL and JSON.

FCPXML is the important one, because it is an interchange format rather than a rendering format. Writing FCPXML means the timeline can be handed to Final Cut Pro with cuts and metadata intact rather than as a flattened file. EDL is the older broadcast interchange format and serves a similar purpose with far less expressiveness. JSON appears to be the native interchange option, useful if the next tool in the chain is a script.

Proxy generation is done through GStreamer, with ProRes, NVENC, VAAPI and software encoders listed as the paths. Proxies are the standard answer to the problem of editing 4K or high frame rate footage on a machine that cannot play it back smoothly, and they also make scrubbing on a timeline bearable. The README lists GStreamer as recommended on all platforms and required for some proxies, which is an honest statement given that hardware paths are platform dependent.

Running the application is one command, and the CLI has its own entry point:

# Show commands
cargo run -p cli -- --help

Having a CLI with import, export, convert and analyze verbs means the tool can be scripted into a pipeline rather than operated only through a window.

Opt-in model calls that change nothing by default

Two features involve language models, and the project handles both by making them opt in and local by default.

The screenplay and storyboard helpers work with LLM providers, with OpenAI named as the example. The footage analysis feature uses the Twelve Labs Pegasus model to take a clip, either a direct media URL or an uploaded asset, plus a prompt, and return a textual analysis: a description of the footage, a summary of a take, or a shot list. The README frames the possible uses as auto describing footage, summarising a take and generating a shot list.

What the README emphasises is the isolation. It says nothing here runs unless called explicitly with an API key, and that it does not affect existing behaviour. The API surface is small:

use desktop::footage_analysis::{FootageAnalyzer, PegasusConfig, VideoSource};

let analyzer = FootageAnalyzer::new(PegasusConfig::new(std::env::var("TWELVELABS_API_KEY")?))?;

The API key comes from an environment variable at construction time, and there is an integration test that makes a real Pegasus call and is skipped unless a key is present. That is a well behaved integration: no hidden network calls, a test that quietly opts out, and a named provider rather than an abstract integration layer.

The repository tree backs the feature list up. There is a `formats/` directory holding JSON specs for screenplay and storyboard, a `default_image_storyboard.json` at the root, a `relay/` directory, a `confirm_event.py` script, a `Cross.toml` with a `Dockerfile.cross` for cross compilation, and a `.continue/` directory.

Editorial conclusion

Gausian is aimed at a specific workflow: generating footage with a local ComfyUI install, cutting it together on a timeline, and handing the result to Final Cut Pro or a linear editor through FCPXML. The architecture is well organised for that, with timeline, project storage, media IO, renderer, exporters, decode and CLI each in its own crate, and the CLI means the tool is scriptable rather than desktop only. Two boundaries are worth knowing before you commit: there is no cloud path at all, since a comment in the README says the relay section was removed because cloud connections are not available, and the license is unasserted, which is not a licence. Start with the prerequisites, FFmpeg on PATH and GStreamer, then run the desktop binary and import media before wiring ComfyUI to anything.

Frequently asked questions

Official sources

1. gausian-AI/Gausian_native_editor on GitHub
2. Issues
3. Project website
4. README
5. Releases