Introdução

Quem já usou o DaVinci Resolve sabe que, hoje em dia, ele é um dos melhores editores de vídeo do mercado, principalmente para um software gratuito, com uma experiência impressionante.

Porém, usar o DaVinci Resolve no Linux é uma luta sinistra.

Logo de cara, fazer a aplicação abrir já é um desafio: é preciso instalar os drivers certos e uma série de dependências.

Mas o problema de verdade aparece mesmo com codecs e arquivos MP4.

O problema

No Linux, o Resolve simplesmente se recusa a trabalhar direito com determinados codecs.

Arquivos MP4, que funcionam sem dor de cabeça em outras plataformas, podem travar o projeto antes mesmo de começar.

A solução

Nesse sentido, encontrei um script que usava o ffmpeg para converter os vídeos em MP4 para o formato MOV, que tem muito mais compatibilidade no Linux.

Mas claro: ficar rodando esse script na mão toda hora é uma merda.

Foi aí que, como eu estava querendo testar o Kimi-K3, resolvi dar uma chance para ele nessa jornada.

Etapas da solução

Assim, definimos as seguintes etapas para a solução:

Levantamento de requisitos funcionais

O primeiro passo foi entender exatamente o que a ferramenta precisava fazer.

Prototipação

Fiz a prototipação usando o Pencil com algum agente de IA.

Codificação

Combinei spec driven development com o opencode. Para isso, optei por usar openspec + opencode + Kimi 3.

Instaláveis

Por fim, gerei os instaláveis para Linux e Windows, usando AppImage e .exe.

Sobre a solução

O Vinci Convert é uma reimaginação em Python do davinconv (um script bash de Gohny), mas com recursos extras: uma interface de terminal com progresso ao vivo, um app desktop em PySide6, varredura recursiva de diretórios e tooling moderno de Python via uv.

Funcionalidades

Converter arquivos únicos ou diretórios inteiros (de forma recursiva) para ProRes;
Detecção automática de pixel format — alterna entre ProRes HQ (422), ProRes 4444 (com alpha) ou copy direto do stream;
Exportar de volta para H264 para entrega;
Tema Catppuccin Mocha — tanto na TUI quanto na GUI;
Duas interfaces: um CLI com rich/typer e uma janela desktop em PySide6;
Construído sobre ffmpeg / ffprobe — sem perda de qualidade no modo copy.

A lógica de conversão sonda a fonte com o ffprobe, detecta o pixel format e escolhe o perfil ProRes correto:

Alpha (yuva/rgba), .mov de 12 bits → copy direto do stream;
Alpha (yuva/rgba) → prores_ks perfil 4444 (yuva444p10le);
Padrão → prores_ks perfil 3 HQ (yuv422p10le).

O áudio é sempre codificado como pcm_s16be (não comprimido, amigável ao Resolve).

Estrutura do projeto

vinci-convert/
├── pyproject.toml
├── README.md
├── .github/workflows/
│   └── release.yml      # CI: builda AppImage + instalador Windows, publica releases
├── packaging/
│   ├── cli_launcher.py  # scripts de entrada do PyInstaller
│   ├── gui_launcher.py
│   ├── vinci-convert.spec       # spec do PyInstaller (CLI)
│   ├── vinci-convert-gui.spec   # spec do PyInstaller (GUI)
│   ├── generate_icons.py        # gerador de ícones (QPainter, Catppuccin)
│   ├── assets/                  # vinci-convert.png / .ico gerados
│   ├── linux/                   # AppRun, .desktop, metadados AppStream, script do AppImage
│   └── windows/
│       └── installer.iss        # instalador Inno Setup
└── src/vinci_convert/
    ├── __init__.py
    ├── __main__.py      # python -m vinci_convert
    ├── cli.py           # CLI em Typer
    ├── converter.py     # lógica do ffmpeg (compartilhada entre CLI e GUI)
    ├── theme.py         # paleta Catppuccin (Rich terminal)
    ├── tui.py           # UI de progresso ao vivo em Rich (CLI)
    ├── qss.py           # paleta Catppuccin + stylesheet QSS (GUI)
    ├── workers.py       # workers ffmpeg em QThread (GUI)
    └── gui.py           # janela desktop em PySide6 (GUI)

Tecnologias usadas

Python ≥ 3.11 — linguagem principal;
uv — gerenciamento de dependências e instalável via CLI;
PySide6 — aplicação desktop;
Typer + Rich — CLI e progresso ao vivo no terminal;
ffmpeg / ffprobe — conversão e sondagem dos vídeos;
PyInstaller — empacotamento dos binários;
Inno Setup — instalador do Windows;
AppImage — instalável portátil do Linux;
GitHub Actions — CI para buildar e publicar as releases.

Vale a pena?

Se você trabalha com DaVinci Resolve no Linux, a resposta é sim.

O problema de codecs e MP4 é um obstáculo real e recorrente, e ter uma ferramenta própria que resolve isso em um clique muda completamente o fluxo de trabalho.

E o melhor: no processo, ainda consegui testar o Kimi-K3, que se mostrou um ótimo companheiro de jornada, do levantamento de requisitos à geração dos instaláveis.

Referências

https://github.com/Jhonatanmizu/vinci-convert

https://github.com/gohny/davinconv

https://www.ffmpeg.org/

https://docs.astral.sh/uv/

https://doc.qt.io/qtforpython-6/

https://opencode.ai/docs/