# redox-wayland-compositor

Portage de Wayland sur Redox OS, en Rust pur, visant à terme à remplacer
Orbital comme serveur graphique de base.

**État** : phases 1+2+3 du plan directeur complétées le 2026-05-08.

Le pipeline shm Wayland complet est validé end-to-end sur Redox via redoxer
(crate `redox-wl-test-shm-pipeline`) : socket Unix réel, `wl_compositor` +
`wl_shm` globals, fd passing via SCM_RIGHTS, `wl_shm_pool` + `wl_buffer`,
`wl_surface.attach`/`damage`/`commit`, lecture pixels côté serveur via le
fd reçu — pixel-perfect.

## Structure

```
.
├── REDOX_COSMIC_XWAYLAND_RS_PLAN.md   # plan directeur 14 phases / 5 ans
├── docs/
│   ├── existing-redox-gui.md          # phase 1 : audit Orbital + graphics-ipc + inputd + relibc
│   └── redox-wayland-primitives.md    # phase 2 : 5 primitives + POC pixels validés sur Redox
├── crates/
│   ├── redox-wl-test-unix-socket/        # primitive 1 : SOCK_STREAM Wayland-shaped
│   ├── redox-wl-test-fd-passing/         # primitive 2 : SCM_RIGHTS mono-process (artefact)
│   ├── redox-wl-test-fd-passing-fork/    # primitive 2b : SCM_RIGHTS via fork (vrai cas Wayland)
│   ├── redox-wl-test-shm-open/           # primitive 3 : shm_open + mmap MAP_SHARED
│   ├── redox-wl-test-poll-multifd/       # primitive 4 : poll() multiplexing + POLLHUP
│   ├── redox-wl-poc-pixels/              # POC : datapath shm + SCM_RIGHTS bout en bout
│   ├── redox-wl-test-handshake/          # phase 3 : wayland-rs server/client registry
│   ├── redox-wl-test-shm-pipeline/       # phase 3 : pipeline shm complet validé
│   └── redox-wl-test-display-backend/    # phase 4.1 : ouvre display Redox via inputd + V2GraphicsHandle
└── (pas de Cargo.toml racine : chaque crate est standalone — voir note ci-dessous)
```

> **Note structure** : pas de workspace Cargo racine. Chaque crate dans `crates/`
> est autonome avec son propre `Cargo.toml` et son propre `target/` lors de la build.
> Raison : `redoxer build`/`redoxer run` cherche le binaire dans `<crate>/target/...`
> et n'arrive pas à le retrouver si le `target/` est centralisé au niveau workspace.
> Ce sera repensé quand on aura un compositor unique vs plusieurs binaires de tests.

## Prérequis

- Rust nightly (récent — testé 2026-05-07)
- Target installé : `rustup target add x86_64-unknown-redox --toolchain nightly`
- `cargo install redoxer` puis `redoxer install` (sysroot Redox ~456 Mo)
- Repo upstream `Smithay/wayland-rs` cloné en `../wayland-rs/` (paths relatifs depuis `crates/*/Cargo.toml`)

## Reproduire les tests

Chaque crate s'exécute via redoxer (mini-VM Redox sous QEMU) :

```bash
cd crates/redox-wl-test-shm-pipeline
redoxer run --release
```

Pattern attendu en fin d'exécution : `[test-XX] PASS: ...`.

> **Important** : utiliser `redoxer build` ou `redoxer run`, **pas** `cargo build --target=x86_64-unknown-redox` direct
> qui fait un fail au link (`undefined reference CMSG_NXTHDR/CMSG_DATA`) parce que le linker host
> ne sait pas chaîner librelibc.a du sysroot Redox. `redoxer` configure le linker correctement.

## Tests qui exigent un vrai framebuffer

Les binaires qui touchent au display (à partir de `redox-wl-test-display-backend`)
ne tourneront pas sous `redoxer run` standard car celui-ci est headless.
Deux voies pour les exécuter :

### Voie A — `redoxer exec --gui` (mini-VM interactive)
```bash
cd crates/redox-wl-test-display-backend
redoxer build --release
redoxer exec --gui target/x86_64-unknown-redox/release/redox-wl-test-display-backend
```
Ouvre une fenêtre QEMU, boote une mini-VM Redox avec framebuffer, lance le binaire.
À fermer manuellement quand le test est fini.

### Voie B — Image complète + `make qemu`

Pousser le binaire dans une image Redox bootable via redoxfs-fuse, puis booter
en mode interactif. Étapes :

```bash
# 1. Monter l'image (redoxfs reste en foreground tant que monté)
mkdir -p /tmp/redox-mnt
~/Projets/Redox/redox-src/build/fstools/bin/redoxfs \
    ~/Projets/Redox/redox-src/build/x86_64/desktop/harddrive.img \
    /tmp/redox-mnt &
sleep 2

# 2. Copier le binaire dans /usr/bin de l'image
cp ~/Projets/Redox/redox-wayland-compositor/crates/redox-wl-test-display-backend/target/x86_64-unknown-redox/release/redox-wl-test-display-backend \
    /tmp/redox-mnt/usr/bin/

# 3. Démonter
fusermount -u /tmp/redox-mnt
rmdir /tmp/redox-mnt

# 4. Booter (avec clavier FR si besoin, voir hook QEMU_USER_FLAGS dans mk/qemu.mk)
cd ~/Projets/Redox/redox-src
make qemu audio=no QEMU_USER_FLAGS="-k fr"
```

Une fois Redox bootée :
- **Ctrl+Alt+F2** pour basculer sur le **VT 2 (console texte)**, sans Orbital
- Login : `root` / mot de passe `password`
- Lancer : `redox-wl-test-display-backend`

> Le binaire écrit aussi sur `/scheme/debug` (serial), donc même si tu lances
> depuis Orbital (VT 3) la sortie sera visible côté host dans le terminal qui
> a lancé `make qemu`.

## Roadmap

Voir `REDOX_COSMIC_XWAYLAND_RS_PLAN.md` pour le plan complet 14 phases / 5 ans.

Prochaine étape : **phase 4 — display backend Redox via `graphics-ipc::V2GraphicsHandle`**.

## Licence

Leyoda 2026 — GPLv3+