< the skull

CONSTRUINDO SOLEDADE
====================
2026-09-11

Há um tempo eu vi algo extremamente interessante, um projeto chamado Nightfall
City [1] e achei fantástico de uma pessoa que usa o pseudônimo de m15o, e achei
fascinante.

Comecei a seguir de perto os projetos do m15o e quanto mais eu aprendia, mais
queria entender sua criatividade e capacidade de modificar recursos e criar
coisas novas.

Uma coisa me chamou mais atenção, dentre todas as coisas que vi: o protocolo que
foi utilizado para Nightfall City.

Então me ocorreu que eu poderia talvez criar meu próprio protocolo e iniciar um
projeto similar baseado inteiramente nele.

Então iniciei a construção do SOLED/2.

O que é
-------

Soledade se apresenta como “um blog textual, quieto e feito à mão”. Por baixo
dessa frase existe uma metáfora que organiza o sistema inteiro: o site é uma
pequena cidade.

  * Cada autor é um cidadão, com uma casa textual própria em `/@nome/`.
  * Cada tema é um bairro — Cinema, História, Livros, Programação, Geral.
  * A home é a Praça Central, onde se reúnem os últimos escritos.
  * Textos podem virar cartas endereçadas a outro cidadão, e a curadoria vira
    jornal e coleções.

Nada disso depende de JavaScript no navegador. O visitante recebe apenas HTML e
CSS — a cidade é estática, e a lógica toda vive antes, no momento em que o texto
é publicado.

*

A cidade por dentro
-------------------

Cidadãos, bairros e casas
-------------------------

A cidadania é aberta: qualquer pessoa se registra por terminal, escolhe um
handle e recebe uma identidade técnica (um segredo com hash SHA-256 — não é
documento oficial). A partir daí já pode publicar. O Prefeito modera depois, se
precisar.

A cada texto publicado corresponde um arquivo `.md` dentro de `content/`, com um
pequeno cabeçalho YAML (o _front matter_) que diz o título, o bairro, as tags e
a data:

  ---
  title: "A canção de Cassilda"
  citizen: "pablo"
  district: "cinema"
  tags: ["ensaio", "carcosa"]
  date: "2026-06-01"
  ---
  

  # O corpo do texto vem aqui, em Markdown.
  

*

Como funciona
-------------

A arquitetura em uma frase
--------------------------

Publicar é gravar um arquivo. Ler é um `cat`. A partir dessa ideia, o sistema
tem três peças de infraestrutura e um pacote Python que costura tudo — sem
Django, sem Flask, sem framework web.

Duas portas TCP, dois papéis
----------------------------

A cidade não tem login no navegador. Toda a escrita e leitura “por dentro”
acontece por TCP puro, atendido por dois pequenos servidores escritos só com a
biblioteca padrão do Python:

  * Porta 1900 — leitura (inspirada nos servidores estilo _Nex_): você manda um
    caminho e recebe o Markdown bruto, ou a listagem de um diretório. Não
    autentica: quem alcança a porta, lê.
  * Porta 1915 — publicação: aceita o protocolo SOLED/2 (identidade cidadã) e um
    protocolo legado do Prefeito. Cada publicação bem-sucedida dispara um
    rebuild na hora.

O caminho de um texto até a web
-------------------------------

  você, no terminal (ncat)
          |
          | porta 1915 · SOLED/2 + identidade
          v
  
  public/         ── HTML estático
          |
          v
  
  Caddy :443      ── HTTPS automático
          |
          v
  
  navegador
  

O `build.py` limpa a pasta `public/` e a regenera inteira a cada vez: páginas,
índices por ano/mês, páginas de bairro, tags, feeds RSS (global, por cidadão e
por bairro), `sitemap.xml`, 404 e um endpoint de saúde. O visitante final só
toca em arquivos estáticos servidos pelo Caddy, que cuida do HTTPS sozinho.

*

A experiência
-------------

Publicar por linha de comando
-----------------------------

Como não há formulário, o cidadão monta um “pacote de texto” e envia com ncat
(ou `nc`). O site inclui um guia inteiro para isso. Um envio SOLED/2 tem esta
forma — a identidade real fica no lugar do marcador:

  # enviar um texto para a cidade (porta 1915)
  
  SOLED/2
  CITIZEN pablo
  IDENTITY <sua-identidade-cidadã>
  PATH citizens/pablo/posts/meu-texto.md
  
  ---
  title: "Meu texto"
  district: "cinema"
  ---
  
  # Corpo do texto
  
  .
  

O protocolo tem mais verbos: `REGISTER` (virar cidadão), `PREVIEW` (validar sem
gravar), `LIST` (listar seus arquivos) e `RECOVER` (recuperar a identidade). Há
limite de taxa por IP e moderação — banir IP ou cidadão — quando necessário.

*

Ficha técnica
-------------

Do que a cidade é feita
-----------------------

A apresentação é um único arquivo `base.html`: tema escuro, fonte monoespaçada,
CSS embutido, nenhum pipeline de front-end. Toda a instalação em servidor é um
script bash idempotente que prepara pacotes, `venv`, `systemd`, Caddy e firewall
de uma vez.

*

Por que assim
-------------

A filosofia de design
---------------------

  * Texto primeiro. Publicar é gravar um arquivo; ler é um `cat` ou uma linha de
    TCP.
  * Estático na web. O visitante recebe HTML e CSS. Zero lógica no request HTTP.
  * Rebuild síncrono. Cada publicação regenera o site imediatamente.
  * Poucas dependências. Quanto menos peças, menos coisa para quebrar ou
    envelhecer.
  * Segurança por camadas. Identidade cidadã, limite de taxa, moderação e
    bloqueio de path traversal na leitura e na escrita.

> Feito em texto. Servido por silêncio. Lido por navegador ou terminal.
> — o rodapé de toda página em Soledade

Soledade é, no fim, uma aposta calma: que um lugar de escrita pode existir sem
métricas, sem infinito scroll e sem algoritmo — só casas, bairros e palavras. A
cidade está aberta, e a cidadania também.

Visite a cidade em soledade.city [2] :)

Links:
  [1] https://nightfall.city/
  [2] https://soledade.city


< the skull