Versionamento com Git🔗

O .mm é XML de texto puro, o que faz dele um cidadão de primeira classe num repositório Git. Você ganha histórico completo, desfazer sem limite de sessão, comparação entre versões e trabalho em equipe — coisas que nenhum recurso interno do Freeplane oferece.

Começando🔗

mkdir mapas && cd mapas
git init
cp ~/meus-mapas/*.mm .
git add .
git commit -m "mapas iniciais"

Uma pasta com os mapas, as imagens numa subpasta img/, e o repositório em volta.

O .gitignore🔗

O Freeplane deixa arquivos temporários que não devem entrar no histórico:

# Cópias de recuperação e backups
*.mm.autosave*
*.mm.bak
*~

# Bloqueio de arquivo aberto
*.mm.lck
.~lock.*

# Sistema
.DS_Store
Thumbs.db

Sem isso, cada gravação polui o git status.

Lendo um diff🔗

git diff mapa.mm

O resultado é XML, mas legível:

-    <node TEXT="Contratar dev" ID="ID_1" MODIFIED="1690000000000">
+    <node TEXT="Contratar desenvolvedora sênior" ID="ID_1" MODIFIED="1690003600000">
+      <attribute NAME="prazo" VALUE="2026-09-15"/>

Dá para ver exatamente que o texto mudou e que um atributo foi acrescentado. O ID estável é o que torna isso possível: o mesmo nó é reconhecível entre versões, mesmo se mudar de lugar.

Reduzindo o ruído🔗

Alguns hábitos deixam os diffs muito mais úteis:

1. Commits pequenos e frequentes. Um commit por sessão de trabalho, com mensagem que diga o que mudou no pensamento, não no arquivo.

2. Não commite mudanças só de dobramento. O estado dobrado é gravado no arquivo, então abrir e fechar ramos gera diff. Se isso incomodar, padronize: dobre até o primeiro nível antes de salvar.

3. Cuidado com o atributo MODIFIED. Todo nó tocado ganha carimbo novo. Nas preferências dá para desativar a gravação de datas de criação/modificação, o que limpa muito os diffs — ao custo de perder essa informação.

4. Imagens referenciadas, não embutidas. Uma imagem embutida em base64 vira um blob gigante que muda por inteiro a cada gravação.

5. Um assunto por mapa. Mapas menores dão históricos compreensíveis e reduzem conflitos.

Conflitos🔗

Aqui está o ponto delicado. Quando duas pessoas editam o mesmo mapa, o Git tenta unir o XML e frequentemente consegue — desde que tenham mexido em ramos diferentes. Quando não consegue, o resultado é um .mm com marcadores de conflito, que o Freeplane não abre.

O procedimento:

# 1. Guarde as duas versões antes de qualquer coisa
git show :2:mapa.mm > /tmp/minha.mm
git show :3:mapa.mm > /tmp/dela.mm

# 2. Abra as duas no Freeplane, lado a lado
freeplane /tmp/minha.mm /tmp/dela.mm

A partir daí, o caminho confiável não é editar o XML: é escolher uma das versões como base, copiar do outro mapa (Ctrl+C / Ctrl+V de ramos inteiros) o que faltar, e commitar o resultado.

cp /tmp/resolvido.mm mapa.mm
git add mapa.mm
git commit

O add-on Mind Map Diff ajuda muito nessa hora: ele compara dois mapas e mostra o que difere, em vez de você conferir a olho.

Evitando conflitos🔗

Melhor que resolver:

• Divida os mapas. Um mapa por pessoa ou por área elimina a maior parte dos conflitos.
• Combine quem mexe em quê. O protocolo social resolve o que a ferramenta não resolve.
• git pull antes de abrir, git push depois de salvar. A janela de conflito encolhe.
• Branches para trabalho longo, com merge consciente no fim.

Git LFS🔗

Se houver imagens grandes ou mapas com anexos embutidos:

git lfs install
git lfs track "*.png" "*.jpg" "*.mmx"
git add .gitattributes

Isso mantém o repositório leve. Para mapas .mm puros não é necessário — texto é exatamente o que o Git faz melhor.

Um driver de diff mais legível🔗

Para diffs mais amigáveis que XML cru, dá para registrar um driver que converte o mapa em texto antes de comparar:

# .git/config
[diff "freeplane"]
    textconv = /usr/local/bin/mm2txt

*.mm diff=freeplane

Onde mm2txt é um script seu — pode ser um script Groovy do Freeplane em modo linha de comando, ou um pequeno programa que percorre o XML e imprime a árvore indentada. É trabalho, mas transforma a experiência.

Hospedagem🔗

Qualquer serviço Git serve: Forgejo, Gitea, GitHub, GitLab, ou um repositório nu numa máquina sua. Como os mapas são texto, o custo é irrisório.

Para mapas pessoais, um repositório privado sincronizado entre máquinas resolve backup, histórico e portabilidade de uma vez — melhor que qualquer pasta de nuvem.

Na prática🔗

1. Crie um repositório com dois mapas e o .gitignore acima.
2. Faça três commits em momentos diferentes de edição.
3. Rode git log -p e leia a história.
4. Provoque um conflito: edite o mesmo nó em dois clones e faça merge.
5. Resolva pelo método de copiar ramos entre mapas abertos.
6. Desative a gravação de datas de modificação e compare o tamanho do diff seguinte.

Referências🔗

1. Freeplane — Working with mind map files
2. Freeplane — Current Freeplane file format (arquivo)
3. Freeplane — Git how-to (desenvolvimento)