# raea 0.1.8

> raea on Windows works: agents install and connect, phone and camera video plays, the local models set themselves up, and the installer asks where to go. Also your edit as layers for CapCut, Premiere and Resolve, labels on what agents show you, and a lighter app.

raea 0.1.8 makes raea on Windows work the way it does on a Mac. Your AI agents install and connect, a phone's or a
camera's video plays, the local models set themselves up with nothing installed first, the app draws on every kind
of graphics card, and the installer asks where raea goes. It also exports your edit as layers for CapCut, Premiere
Pro and DaVinci Resolve, has agents label what they show you, and makes the app lighter and quicker.

**Get the app at [raea.io](https://raea.io)** (a Mac with Apple silicon, Windows 10 or 11, or Linux on x86_64).

The engine alone:

```sh
curl -fsSL https://raea.io/install | sh
```

On Windows, in PowerShell: `irm https://raea.io/install.ps1 | iex`.

## What changed since 0.1.7

**raea on Windows works.**
- Nothing needs installing first, and nothing has to download. The app carries what raea needs from outside it:
  Git, FFmpeg, uv (which sets up the local models) and Microsoft's Visual C++ runtime, so it works on a work PC
  that blocks downloads. Before, raea.exe wouldn't start without the Visual C++ Redistributable, and a workspace
  couldn't be made without Git.
- ChatGPT, Claude, Gemini, OpenCode and Kimi install and connect on a Windows PC.
- The app calls your PC a PC: Ctrl, not ⌘, everywhere, the whiteboard too.
- The installer asks where raea goes. It suggests a folder in your own profile, takes any empty folder you can
  write to (or the folder raea is already in), and says why it won't use one that already holds other files. An update goes
  where the last install went, and uninstalling removes raea's own files and nothing else.
- The app draws on every kind of graphics card. On a PC with Intel or AMD graphics, including a laptop with AMD
  graphics beside an NVIDIA card, raea draws with DirectX 12. Before, the app could crash at launch on those
  (#155) and on Intel's integrated graphics. 3D on DirectX 12 is now drawn as on a Mac; with `WGPU_BACKEND=dx12`
  set by hand, 0.1.7 drew a scene's shapes into one another.
- A phone's or a camera's video plays, probes and checks. raea's own decoders read H.264 without B-frames, which is
  what raea writes, and the FFmpeg in the app reads the rest (most phone and camera footage: H.264 with B-frames,
  HEVC, VP9). It's built from FFmpeg's own source with no GPL part (FFmpeg's code and libvpx's decoders, for
  WebM with transparency), so its licence is the LGPL, and its source is published beside raea's releases. A clip
  raea cuts for you to play, such as `raea notes check`'s, uses Windows' own H.264 encoder. With raea from the zip and no FFmpeg on the PC, raea fetches
  the same build once and checks it before use.
- Agents' npm tools and MCP servers start without a shell, and their arguments arrive as written in folders with
  spaces or letters outside ASCII.
- Workspaces work (#169). raea wrote Windows' `\\?\` form of a folder's path into a workspace's `.git/config`, so
  every Git command in it failed and the app couldn't finish its first run, and a workspace's folder came out
  doubled when `raea.root` wasn't set. On a PC whose only Git is the app's, or none at all, `raea workspace`,
  `project` and `controller` use the app's Git or Git for Windows, or fetch raea's own once.
- The app no longer crashes at launch with a stack overflow (#112, #124). Its page host has the 8 MB stack it has on a
  Mac, and turns a file's bytes into text a piece at a time.
- What your agent runs through raea understands Windows. `raea show` finds the app wherever the installer put it,
  starts it, opens files in Explorer, and no longer says it opened them "in the Mac's own viewer". `raea init`,
  `show`, `cut` and `brand` take `C:\` and `\\server\share` paths, which they used to treat as relative ones.
- Numbers, money and dates format on Windows and Linux. `toLocaleString` and `Intl` in a composition threw "Intl is
  not defined" there; they now give the Mac's answers, in English and 40 other languages.
- `--quality master` keeps a dark background that changes slowly, such as a glow drifting over black, clean. It came
  out blotchy before.
- raea starts on a PC whose processor has no AVX2, such as an Intel Core from 2011 or 2012 (#110), or no AVX at all,
  such as a Celeron or Pentium from 2016 to 2019 or a Core from 2008 to 2010. Two things stopped raea.exe before it
  did anything. The ONNX Runtime raea linked was built for newer processors: raea now loads Microsoft's own build when
  a model first runs, and it picks its code for the processor it finds. And Bevy's texture compressors, which raea
  never used, set up their AVX2 tables at start on every processor: they're no longer in raea.

**Local models with nothing installed first.** Stable Audio Open's sound effects, matchmove (`raea track`),
Gaussian splats (`raea splat train`), liquids and TokenSynth's instruments set themselves up on a Mac, Windows or
Linux. You don't need Homebrew, Python, Git or FFmpeg. raea fetches its own uv the first time, checks it, and each
model brings its own Python. Off a Mac, Stable Audio Open runs on ONNX Runtime, on the GPU when there's an NVIDIA
card. A download that drops partway through picks up where it stopped, so a 2 GB install on a shaky connection
still finishes.

**Your edit, as layers.**
- `raea export layers` writes each layer of a composition and a `layers.json`.
- A CapCut draft is made from that file, with the captions on their own track.
- `raea export xml` opens in Premiere Pro and DaVinci Resolve as raea drew it, with moving footage keyed.

Thanks @wackyza, who specified this and built it (#166, #170, #171, #172).

**Labels on what agents show you.** A contact sheet, a side-by-side or a scene comes with short tags beside the
picture, never on it. Hover one and a line draws to what it means; click it for the why. A feed card says how many
labels its item has. From the terminal: `raea show --label`, `--detail` and `--labels`, and `raea media sheet`
writes the sheet's labels beside it.

**A lighter, quicker app.**
- A long feed of stills took raea's window past 2.5 GB; it now stays near 1.3 GB. Each picture is decoded at the
  size it's drawn, cards far off screen let theirs go, and the window keeps one copy of what it shows.
- Scrolling the feed, opening an item and loading more stay within their frame budgets on Mac, Windows and Linux.
  Cards redraw only when what they draw changes.
- The chat header shows one chat at a time, the one you're in, and dragging a chat out of it carries that chat.
- On the Mac, raea starts one window: never a second beside yours, and never from the update folder. A copy left in
  the update folder opens the installed app.

**3D that moves keeps moving.** In a live play, an animated material or a shader's time runs on past the first
frame, on Windows too.

**Linux renders 3D again.** raea built from source on Linux stopped at a 3D render ("Failed to build event loop",
#182). Every engine raea makes now leaves the window to the app, under X or with no display at all.

**For builders.**
- A composition says what a person might tune in `controls`: a number with its range, a switch, a choice, a
  colour or some text, grouped and labelled. A part deep in the tree reads one with `useControl("name")`, and the
  item's Controls tab moves them on the live picture.
- `@shared/` imports render. A composition that imports `@shared/components/NAME` from its workspace's `shared/`
  folder renders from the terminal as it does in the app.
- raea/wear weathers a model by what weathers it. `wearBake` (and `raea wear bake`) works out once where rain
  reaches and runs, where the sun falls, what people touch and how high each point stands over the street.
  `wearShader` draws soot, stains, damp, rust, peeling paint and worn edges by material (plaster, brick, stone, wood,
  iron and nine more), with the season's rain, snow, dust or leaves over them. `WEAR_CONDITIONS` holds eight ready
  ones, from spring's damp to a thunderstorm's soaking, and `weatherAt` changes the weather during a shot: a front
  darkens over the minutes rain takes to soak it and dries over the hour after, snow settles and frost forms, and any
  frame can be drawn alone. examples/materials/wear shows each condition by day and at dusk.
- `raea check` reads a video without FFmpeg. Where FFmpeg isn't installed, raea's own readers stand in, held to
  FFmpeg's answers.
- `raea gen`: a fal step sends the resolution and aspect ratio its model takes, an image edit's mask reaches the
  model, and a file changed in place counts as a new input.
- An agent's error says its own words, such as a used-up plan, instead of "Internal error".
- `WGPU_BACKEND` picks the graphics API raea draws with (`dx12`, `vulkan` or `gl`), when you need to override its
  choice.
- The raea skill gains video-decompiler, James Dimachkie's skill for making a short product film as raea code
  (MIT).

**Known**
- On Linux, raea needs a processor with AVX (most from 2011 on) and glibc 2.39 or newer (Ubuntu 24.04, Debian 13,
  Fedora 40 and later).
- On Windows with Intel or AMD graphics, DirectX 12 compiles 3D shaders more slowly, so a 3D render can take
  about 15 seconds longer to start.
- On Windows, TokenSynth runs on the CPU, so each note takes a minute or more to make.
- A seek while a film plays in the timeline can show one frame from before the seek (about 33 ms) before it jumps.
- A long 4K `raea render` can still hang before its first frame (#158).
- Characters (the Character SDK) come in a later release.
- R3F's pointer input has no double click yet, and touches don't arrive as pointers.
- postprocessing's Outline, TextureEffect, DepthEffect and LUT1D, and TSL's OutlineNode, are skipped, with one
  warning that names them.
- The Windows app is unsigned, as before: Windows asks once whether to run it.
- A proxy set by an automatic configuration (PAC) file isn't read. If yours uses one, start raea with `HTTPS_PROXY`
  set.
