Pesquisa e guia técnico
Data: 2026-06-22
Foco: Windows .exe, diskmag/e-zine executável, distribuição moderna, stack prática e estética retrô sem gambiarra burra.

1. Resposta direta

Hoje, uma diskmag para Windows seria feita como um aplicativo desktop multimídia offline.

Ela pode ser:

um .exe único;
um .exe + pacote de dados;
um .zip portátil;
um instalador .exe;
um .msi;
um pacote MSIX/Microsoft Store.

A estrutura básica continua igual à dos diskmags clássicos:

engine + conteúdo + arte + música + navegação + créditos

A diferença é que hoje você tem engines e bibliotecas muito melhores.

Uma diskmag moderna não precisa ser “um PDF dentro de um EXE”. Isso seria preguiçoso. O valor do formato executável é entregar uma experiência própria:

tela de abertura;
menus;
música;
animação;
arte pixel/ANSI/VGA;
navegação por teclado;
créditos;
artigos;
busca;
easter eggs;
modo offline;
identidade visual fechada.

Se for só texto empacotado, melhor publicar HTML/PDF. O .exe só faz sentido quando o próprio leitor vira parte da obra.

2. O que uma diskmag `.exe` tem por dentro

Uma diskmag moderna costuma ter estes componentes:

Diskmag.exe
  ├── app shell / engine
  ├── renderer de textos
  ├── sistema de menus
  ├── player de áudio
  ├── renderização gráfica
  ├── assets visuais
  ├── dados dos artigos
  ├── metadados da edição
  ├── créditos
  └── opções/configurações

Em versão portátil:

MuradDiskmag01/
  MuradDiskmag01.exe
  content.pak
  music/
  assets/
  README.txt
  LICENSE.txt

Em versão “objeto único”:

MuradDiskmag01.exe

Mas cuidado: “single EXE” é bonito como fetiche, porém nem sempre é o melhor tecnicamente. Um .exe com dados externos é mais fácil de atualizar, debugar, preservar e traduzir. Um .exe único é mais elegante como artefato, mas pode ser maior, mais difícil de assinar e mais suscetível a falso positivo se você tentar compactar demais.

3. O que ainda existe hoje

A cena não está morta. Está pequena, mas viva.

Exemplos e sinais:

Hugi, uma das diskmags de PC/demoscene mais conhecidas, ainda mantém arquivo acessível e teve material Windows arquivado em 2026.
Existe um Diskmag Engine in C# / WPF por Hugi/Adok, lançado em 2024, com artigos em .rtf.
Arquivos como Demozoo, Scene.org, Pouët e Hugi ainda preservam diskmags, demos e ferramentas.

Isso importa porque mostra uma coisa simples: se você quiser fazer uma diskmag Windows hoje, você não está inventando do zero. Está atualizando uma tradição.

4. O melhor caminho depende do tipo de diskmag

Não existe uma stack “certa” universal. Existe stack certa para o tipo de experiência.

4.1 Diskmag editorial, com muito texto

Melhor caminho:

C# / WPF
C# / Avalonia
Tauri

Use se a prioridade for:

leitura confortável;
artigos longos;
índice;
busca;
layout editorial;
exportação fácil;
distribuição Windows.

4.2 Diskmag audiovisual, com animação e música

Melhor caminho:

Godot
C++ + SDL2
C++ + raylib
C++ + Dear ImGui

Use se a prioridade for:

transições;
shaders;
pixel art;
cenas animadas;
música sincronizada;
navegação mais “demo/game”.

4.3 Diskmag web-like empacotada

Melhor caminho:

Tauri
Electron

Use se a prioridade for:

HTML/CSS/JS;
UI rápida de prototipar;
conteúdo vindo de Markdown/HTML;
animações CSS;
equipe acostumada com web.

4.4 Diskmag “demoscene raiz”

Melhor caminho:

C++ + SDL2 + OpenGL/Direct3D
C++ + raylib
C++ + Dear ImGui

Use se a prioridade for:

controle total;
binário pequeno;
performance;
sensação de demo real;
minimalismo técnico.

Mas aqui a conta chega: você vai programar mais infraestrutura. Se seu foco é publicar zines, isso pode virar masturbação técnica.

5. Comparativo brutal das stacks

Stack	Melhor para	Vantagem	Desvantagem	Veredito
WPF / .NET	Windows-only, texto, editoria	Rápido, maduro, ótimo para app editorial	Só Windows, visual pode ficar “app corporativo” se não customizar	Ótimo para uma primeira diskmag Windows séria
Avalonia / .NET	Desktop cross-platform	Parecido com WPF, mas multiplataforma	Mais uma camada de aprendizado	Melhor que WPF se você quiser Linux/macOS depois
Tauri	Web UI com app leve	HTML/CSS + Rust backend + instalador	Precisa lidar com Rust e WebView2	Melhor equilíbrio moderno se você quer web + desktop
Electron	Web UI muito rápida	Ecossistema enorme, fácil	Pesado, parece overkill para diskmag pequena	Funciona, mas é o caminho preguiçoso/pesado
Godot	Diskmag audiovisual	Cenas, animação, áudio, shaders, export Windows	Menos “app editorial”, mais “game/app interativo”	Excelente se a diskmag for uma experiência visual
C++ + SDL2	Demoscene raiz	Controle total e portabilidade	Mais trabalho	Bom se você quer construir engine de verdade
C++ + Dear ImGui	UI técnica/fullscreen	Muito rápido para UI custom	Acessibilidade e i18n fracos	Bom para tool/demo, não para revista textual comum
WinUI 3	App Windows moderno	Visual nativo Windows	Deploy mais chato, dependências	Eu evitaria para diskmag
Unity	3D/2D interativo	Ferramental excelente	Pesado demais	Overkill
Python + PyInstaller	Protótipo	Muito rápido	Distribuição Windows pode virar inferno de AV/dependência	Só protótipo

6. Minha recomendação real

Para uma diskmag Windows moderna, eu faria assim:

Se for uma diskmag Murad Press / BBS / terminal / biblioteca

Escolha:

C# + Avalonia

ou:

C# + WPF

Motivo:

excelente para texto;
bom para navegação;
gera .exe;
dá para assinar;
dá para fazer single-file;
combina com leitor editorial;
rápido para desenvolver;
não carrega Chromium inteiro;
não força você a pensar como game.

Se for mais visual, ritualística e audiovisual

Escolha:

Godot

Motivo:

tela cheia;
transições;
áudio;
shaders;
pixel art;
menus;
cenas;
créditos;
exportação Windows fácil;
ótimo para uma diskmag que pareça “artefato”.

Se você quer usar HTML/CSS como layout principal

Escolha:

Tauri

Motivo:

visual web;
menor que Electron;
gera instaladores Windows;
permite usar Markdown -> HTML;
bom para uma edição com layout forte.

O que eu não faria

Eu não começaria com Electron, Unity ou C++ puro.

Electron funciona, mas para diskmag pequena ele é gordo.
Unity é exagero.
C++ puro é bonito, mas você vai gastar tempo criando leitor, layout e pipeline antes de publicar qualquer coisa.

7. Modelo ideal: conteúdo separado do engine

A maior decisão não é a linguagem. É esta:

Não escreva os artigos direto dentro do código.

Use conteúdo estruturado.

Estrutura recomendada:

diskmag/
  engine/
    src/

  issue/
    meta.yaml
    cover.md
    articles/
      001-editorial.md
      002-manifesto.md
      003-entrevista.md
      004-ensaio.md

    assets/
      images/
      ansi/
      fonts/
      shaders/
      audio/

    credits.yaml

Depois, no build, você gera:

build/
  MuradDiskmag01.exe
  content.pak

ou:

build/
  MuradDiskmag01.exe

se embutir tudo.

A regra é:

Markdown é a fonte.
JSON/SQLite/PAK é o formato de leitura.
EXE é o leitor.

Isso deixa a diskmag preservável.

Se daqui a 10 anos o .exe parar de rodar, os textos continuam recuperáveis.

8. Formatos de conteúdo

Fonte editorial

Use:

Markdown
YAML frontmatter

Exemplo:

---
id: "001"
title: "Editorial"
author: "Pablo Murad"
section: "Abertura"
tags: ["editorial", "diskmag", "bbs"]
music: "intro.xm"
background: "blue-grid.png"
---

# Editorial

Todo arquivo quer sobreviver ao suporte que o carrega.

Build intermediário

Converta para:

JSON
SQLite
HTML interno
RTF

Escolhas:

Markdown -> HTML: ótimo para Tauri/Electron.
Markdown -> FlowDocument/RTF: bom para WPF.
Markdown -> JSON AST: bom para engine própria.
Markdown -> BBCode-like: bom para Godot.

Assets

Use:

PNG/WebP        imagens
WAV/OGG/MP3     áudio comum
MOD/XM/S3M/IT   música tracker
TTF/OTF         fontes
ANS/TXT         arte ANSI/ASCII
JSON/YAML       metadados

Para nostalgia real, música tracker (.mod, .xm, .s3m, .it) combina mais que MP3. Mas ela exige player/biblioteca adequada.

9. Arquitetura recomendada

┌────────────────────────────────────┐
│ Diskmag.exe                         │
│ shell / janela / loop principal     │
└──────────────────┬─────────────────┘
                   ↓
┌────────────────────────────────────┐
│ Router de telas                     │
│ intro, menu, artigo, créditos       │
└──────────────────┬─────────────────┘
                   ↓
┌────────────────────────────────────┐
│ Content engine                      │
│ lê índice, artigos, assets          │
└──────────────────┬─────────────────┘
                   ↓
┌────────────────────────────────────┐
│ Renderer                            │
│ texto, imagens, animações, ANSI     │
└──────────────────┬─────────────────┘
                   ↓
┌────────────────────────────────────┐
│ Audio engine                        │
│ música, fade, mute, volume          │
└────────────────────────────────────┘

Estados principais

BOOT
INTRO
MAIN_MENU
ARTICLE_LIST
ARTICLE_VIEW
CREDITS
SETTINGS
EXIT

Eventos

Up/Down      navegação
Enter        selecionar
Esc          voltar
F1           ajuda
M            mutar música
S            buscar
Ctrl+F       buscar no artigo
Left/Right   artigo anterior/próximo

10. Como fazer em WPF / .NET

Este é o caminho mais direto para Windows.

Quando escolher

Escolha WPF se você quer:

Windows apenas;
app editorial;
texto longo confortável;
build rápido;
interface customizada;
single-file .exe;
controle suficiente sem criar engine gráfica.

Estrutura

MuradDiskmag/
  MuradDiskmag.csproj
  App.xaml
  MainWindow.xaml
  MainWindow.xaml.cs

  Core/
    Article.cs
    Issue.cs
    ContentLoader.cs
    NavigationService.cs

  Views/
    IntroView.xaml
    MenuView.xaml
    ArticleView.xaml
    CreditsView.xaml

  Assets/
    Fonts/
    Images/
    Audio/

  Content/
    issue.json
    articles/

Publicação single-file

Exemplo de build:

dotnet publish ./src/MuradDiskmag/MuradDiskmag.csproj \
  -c Release \
  -r win-x64 \
  --self-contained true \
  -p:PublishSingleFile=true \
  -p:EnableCompressionInSingleFile=true \
  -p:IncludeNativeLibrariesForSelfExtract=true

A documentação da Microsoft diz que o single-file pode ser self-contained ou framework-dependent. O self-contained inclui runtime e bibliotecas do framework, então o arquivo cresce. Também há APIs incompatíveis com single-file e casos em que bibliotecas nativas precisam ser extraídas para disco antes da execução.

Como carregar conteúdo

Opção 1: conteúdo externo:

MuradDiskmag.exe
content/
  articles/
  assets/

Opção 2: conteúdo embutido:

EmbeddedResource

Opção 3: pacote próprio:

content.pak

Para v1, eu usaria conteúdo externo durante desenvolvimento e pacote .pak no release.

Visual

WPF permite:

customizar janela sem borda;
usar fontes pixel;
animações básicas;
transições;
FlowDocument para texto;
RichTextBox read-only;
canvas para efeitos;
áudio via bibliotecas .NET ou chamadas nativas.

Exemplo de estilo

janela 1280x720
fundo escuro
coluna esquerda: menu
centro: artigo
rodapé: comandos
música: canto inferior direito

Vantagem real

Você consegue entregar.

Risco

Ficar com cara de aplicativo de contabilidade. O design precisa ser agressivamente customizado.

11. Como fazer em Avalonia / .NET

Avalonia é como um WPF mais moderno e multiplataforma.

Quando escolher

Escolha Avalonia se você quer:

Windows agora;
Linux/macOS depois;
estilo customizado;
stack .NET;
app editorial;
futuro mais flexível.

Estrutura

MuradDiskmag.Avalonia/
  App.axaml
  MainWindow.axaml
  ViewModels/
  Views/
  Models/
  Services/
  Content/

Vantagem

Você não se prende ao Windows.

Desvantagem

Se o objetivo é estritamente Windows .exe, WPF é mais direto. Avalonia compensa quando a ambição é multiplataforma.

Melhor uso

Uma diskmag que também terá versão Linux/macOS para público de demoscene, hacker, BBS e retrocomputing.

12. Como fazer em Tauri

Tauri é a opção web moderna sem carregar Electron inteiro.

Quando escolher

Escolha Tauri se você quer:

interface em HTML/CSS/JS;
animação CSS;
layout editorial bonito;
Markdown convertido para HTML;
backend em Rust;
instalador Windows;
app mais leve que Electron;
possibilidade de usar a mesma base visual na web.

Estrutura

murad-diskmag/
  src-tauri/
    src/
    tauri.conf.json

  src/
    index.html
    main.ts
    styles.css

  content/
    issue.yaml
    articles/
    assets/

Build

npm run tauri build

O Tauri gera instaladores Windows como .msi via WiX ou -setup.exe via NSIS. A própria documentação do Tauri informa que o build Windows pode usar WiX para MSI e NSIS para setup executável.

Visual

Você pode criar algo como:

HTML/CSS editorial
canvas/WebGL para efeitos
howler.js para áudio comum
animações CSS
tema BBS/ANSI

Vantagem

Rápido para fazer bonito.

Desvantagem

Você precisa lidar com o modelo Tauri: frontend web + backend Rust + WebView2 no Windows. Não é difícil, mas é mais complexo que um site estático.

Melhor uso

Uma diskmag que também será publicada como webzine.

13. Como fazer em Electron

Electron é o caminho fácil e pesado.

Quando escolher

Escolha Electron se:

você domina web;
quer entregar rápido;
não se importa com tamanho;
quer usar bibliotecas JS;
quer empacotar um app com Chromium e Node.js.

Electron oficialmente embute Chromium e Node.js para criar apps desktop com HTML/CSS/JS.

Build

Com Electron Forge:

npm init electron-app@latest murad-diskmag
cd murad-diskmag
npm run make

Electron Forge pode gerar formatos específicos por sistema, como MSI, DMG e deb.

Vantagem

Você faz uma diskmag bonita muito rápido.

Desvantagem

Para diskmag pequena, Electron é gordo e meio sem alma. Funciona, mas não é elegante.

Veredito

Eu só usaria se o objetivo fosse publicar logo e reaproveitar uma versão web.

14. Como fazer em Godot

Godot é uma das opções mais interessantes para uma diskmag audiovisual.

Quando escolher

Escolha Godot se você quer:

tela cheia;
cenas;
transições;
pixel art;
shader;
áudio;
menus;
controle por teclado/gamepad;
sensação de “demo interativa”.

Estrutura

MuradDiskmagGodot/
  project.godot

  scenes/
    Intro.tscn
    MainMenu.tscn
    ArticleView.tscn
    Credits.tscn

  scripts/
    ArticleLoader.gd
    Navigation.gd
    AudioManager.gd

  content/
    issue.json
    articles/

  assets/
    fonts/
    images/
    music/
    shaders/

Export Windows

A documentação do Godot explica que o exportador Windows cria um data.pck com os arquivos do projeto e usa um binário otimizado, menor e sem editor/debugger. O Godot também documenta PCK embedding e code signing no export Windows.

Formato dos artigos

Eu faria:

Markdown -> JSON/BBCode

ou escreveria os artigos em um formato simples:

{
  "title": "Editorial",
  "author": "Pablo Murad",
  "pages": [
    "Texto da página 1...",
    "Texto da página 2..."
  ]
}

Visual

Godot permite:

RichTextLabel;
fontes bitmap;
animações;
shaders CRT;
parallax;
áudio com fade;
partículas;
cenas secretas.

Vantagem

Fica com cara de objeto artístico, não de aplicativo.

Desvantagem

Texto longo no Godot exige cuidado. Game engine não é editor de texto. Se a diskmag for 90% leitura, você vai precisar projetar muito bem o leitor.

Melhor uso

Uma diskmag curta/média com forte direção de arte.

15. Como fazer em C++ + SDL2

Este é o caminho demoscene.

Quando escolher

Escolha se você quer:

controle total;
binário leve;
performance;
renderização própria;
shaders;
som;
teclado;
fullscreen;
estética de demo real.

SDL é uma biblioteca cross-platform que dá acesso baixo nível a áudio, teclado, mouse, joystick e gráficos via OpenGL/Direct3D.

Estrutura

src/
  main.cpp
  app.cpp
  renderer.cpp
  audio.cpp
  content.cpp
  article_view.cpp
  menu.cpp

assets/
  fonts/
  images/
  music/
  shaders/

content/
  issue.json
  articles/

Bibliotecas extras

SDL3 ou SDL2
SDL_image
SDL_ttf
SDL_mixer
OpenGL/Direct3D
stb_image
nlohmann/json
libopenmpt

Build

cmake -B build -S .
cmake --build build --config Release

Vantagem

Mais próximo da tradição original de diskmag/demo.

Desvantagem

Você vai implementar muita coisa básica: layout, wrap de texto, scroll, input, assets, empacotamento. Só vale se você quer que o motor seja parte da obra.

16. Como fazer em C++ + Dear ImGui

Dear ImGui é rápido, portátil e excelente para UI técnica. A documentação oficial descreve o projeto como uma GUI C++ “bloat-free”, rápida, portátil, renderer-agnostic e self-contained.

Quando escolher

Escolha se:

você quer UI rápida;
quer algo tool-like;
quer janelas internas;
quer integrar com SDL/OpenGL;
quer fazer uma “diskmag debug/terminal”.

Problema

Dear ImGui não é ideal para uma revista pública refinada. A própria documentação alerta que recursos como acessibilidade, internacionalização complexa e shaping de texto não são foco.

Veredito

Bom para protótipo e engine interna. Menos bom para uma diskmag editorial elegante.

17. Música: como fazer direito

Diskmag sem música é possível, mas perde metade do ritual.

Opções de áudio

Áudio comum

OGG
MP3
WAV
FLAC

Para Tauri/Electron:

howler.js
Web Audio API

Para Godot:

AudioStreamPlayer

Para .NET:

NAudio
ManagedBass/BASS

Para C++:

SDL_mixer
FMOD
miniaudio
BASS
libopenmpt

Música tracker

Formatos:

MOD
XM
S3M
IT
MPTM

Biblioteca recomendada:

libopenmpt

A libopenmpt é baseada no código do OpenMPT e serve para playback de música tracker. É perfeita para estética diskmag/demoscene.

Comportamento esperado

A diskmag deve ter:

M       mute/unmute
+/-     volume
N       próxima música
P       música anterior

E jamais deve obrigar o usuário a ouvir música alta. Isso era aceitável em 1998. Hoje é só irritante.

18. Arte, fontes e visual

Fontes

Para visual oldschool:

fontes CP437;
fontes VGA;
fontes bitmap;
fontes IBM PC;
fontes monospace pixel-perfect.

Recurso útil:

The Ultimate Oldschool PC Font Pack
https://int10h.org/oldschool-pc-fonts/

ANSI/ASCII

Ferramentas:

Moebius
PabloDraw
FIGlet
TOIlet
chafa
jp2a

Arquivos:

16colo.rs
Artpacks.org
Textfiles
Scene.org
Demozoo

Atenção brutal: não copie arte alheia como se fosse sua. Use como referência, peça permissão, credite, ou crie arte própria.

Estética recomendada

Para uma diskmag moderna boa:

- 1280x720 ou 1600x900
- opção fullscreen/windowed
- fonte confortável
- contraste alto
- tema escuro
- cores ANSI com moderação
- animação curta
- zero firula enquanto lê

A pior coisa que você pode fazer é uma interface linda que torna a leitura ruim.

19. Como empacotar assets

Há quatro métodos.

19.1 Assets soltos

Diskmag.exe
assets/
content/

Vantagens:

fácil debugar;
fácil atualizar;
fácil preservar.

Desvantagens:

usuário pode mexer;
parece menos “artefato único”.

19.2 Arquivo `.pak`

Diskmag.exe
content.pak

Vantagens:

mais limpo;
protege contra bagunça;
ainda preservável.

Desvantagens:

precisa criar packer/unpacker.

19.3 Embutir no `.exe`

Diskmag.exe

Vantagens:

bonito;
simples para usuário;
artefato único.

Desvantagens:

build mais pesado;
patch mais chato;
risco maior de complicar assinatura;
pode exigir extração em runtime.

19.4 Instalar em diretório

C:\Users\Pablo\AppData\Local\MuradDiskmag\

Vantagens:

update e config fáceis;
bom para app com várias edições.

Desvantagens:

menos zine-artefato;
mais “software comum”.

Recomendação

Para diskmag numerada:

ZIP portátil com EXE + content.pak

Para público amplo:

setup.exe assinado

Para preservação:

ZIP + código fonte + Markdown + assets

20. Instalação e distribuição

Opção A: Portable ZIP

MuradDiskmag01.zip
  MuradDiskmag01.exe
  content.pak
  README.txt

Melhor para:

demoscene;
itch.io;
GitHub Releases;
arquivo histórico;
distribuição simples.

Opção B: Setup `.exe`

Ferramentas:

NSIS
Inno Setup
Tauri NSIS
Electron Forge/Squirrel

NSIS é um sistema scriptável para instaladores Windows. Inno Setup é um instalador open-source para aplicações Windows.

Melhor para:

público comum;
criar atalhos;
desinstalador;
integração Windows.

Opção C: MSI/MSIX

Melhor para:

ambientes corporativos;
Microsoft Store;
distribuição mais formal;
update/instalação gerenciada.

Opção D: Microsoft Store

Melhor para evitar susto de SmartScreen no usuário comum, mas pior para estética “underground”.

21. Assinatura de código e SmartScreen

Essa parte é chata, mas essencial.

Windows não gosta de .exe baixado da internet. E com razão: .exe aleatório é vetor clássico de malware.

A Microsoft documenta que o SmartScreen avalia reputação do arquivo e do publisher. Arquivos sem assinatura começam sem reputação, e cada nova versão precisa construir reputação de novo se não houver assinatura consistente. A própria documentação também diz que apps publicados pela Microsoft Store são reassinados pela Microsoft e não mostram aviso de SmartScreen para instalação pela Store.

Pontos práticos:

- Assine o executável/instalador se for distribuir publicamente.
- Use sempre o mesmo publisher/certificado.
- Publique SHA256 do arquivo.
- Evite packers suspeitos no começo.
- Não peça permissões administrativas sem necessidade.
- Não escreva fora da pasta do app/config.
- Não baixe código remoto.
- Não execute scripts externos.

EV certificate não é milagre

A Microsoft informa que certificados EV não bypassam mais SmartScreen automaticamente como no passado. Então pagar EV só para “não aparecer aviso” não é uma estratégia garantida.

Melhor prática realista

Para edição artística/underground:

- ZIP portátil
- SHA256 publicado
- assinatura se possível
- página oficial de download
- mirror no itch.io/GitHub Releases/Scene.org se fizer sentido

Para público geral:

- instalador assinado
- página HTTPS oficial
- talvez Microsoft Store

22. O que não fazer

Não faça:

- EXE que baixa conteúdo sem avisar
- EXE que pede admin sem motivo
- EXE que escreve em System32/Program Files diretamente
- packer agressivo estilo “malware cosplay”
- auto-update caseiro inseguro
- esconder payload
- ofuscação desnecessária
- música alta sem controle
- texto em bitmap ilegível
- interface que prioriza efeito em vez de leitura

Se você quer que as pessoas rodem seu .exe, aja como alguém confiável. Nostalgia não justifica parecer malware.

23. Pipeline editorial

O fluxo bom é:

1. Escrever artigos em Markdown
2. Revisar e fechar edição
3. Gerar índice e metadados
4. Otimizar imagens
5. Exportar conteúdo para JSON/SQLite/PAK
6. Rodar diskmag em modo dev
7. Testar navegação/leitura
8. Build Release
9. Assinar
10. Gerar ZIP/installer
11. Gerar SHA256
12. Publicar
13. Arquivar fonte e assets

Makefile conceitual

build-content:
    python tools/build_content.py issue/ build/content.pak

build-app:
    dotnet publish src/MuradDiskmag.csproj -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true

package:
    7z a release/MuradDiskmag01.zip build/MuradDiskmag01.exe build/content.pak README.txt

hash:
    certutil -hashfile release/MuradDiskmag01.zip SHA256

24. Pipeline com GitHub Actions

Fluxo:

push tag v0.1.0
  ↓
build no Windows
  ↓
gerar exe
  ↓
rodar testes básicos
  ↓
assinar
  ↓
gerar zip/installer
  ↓
gerar SHA256
  ↓
criar release

Estrutura:

.github/
  workflows/
    release.yml

A assinatura exige cuidado com secrets. Não coloque certificado privado no repositório.

25. Um design bom para a Murad Diskmag

Se fosse para conectar com seu universo de site terminal/BBS, eu faria assim:

MURAD DISKMAG #001
"The Archive Is Alive"

Tela inicial

╔════════════════════════════════════════════════════╗
║                 MURAD DISKMAG #001                ║
║              THE ARCHIVE IS ALIVE                 ║
╚════════════════════════════════════════════════════╝

[ENTER] iniciar
[M] música
[F11] fullscreen
[ESC] sair

Leitor

┌──────────────────────────────────────────────────────┐
│ 02 / Manifesto do Terminal                           │
└──────────────────────────────────────────────────────┘

Texto paginado em 80-100 colunas, com fundo discreto,
música baixa e navegação previsível.

[N] próximo  [P] anterior  [M] mute  [ESC] voltar

Créditos

Code: Pablo Murad
Writing: Pablo Murad
ANSI/ASCII: ...
Music: ...
Fonts: ...
Tools: ...

Easter eggs

type: invoke qel
type: open terminal
type: sudo archive

Mas cuidado: Easter egg é sal. Se virar prato principal, fica ridículo.

26. Stack recomendada para você

Versão 1: diskmag Windows editorial

C# + WPF
Markdown -> JSON
content.pak
WAV/OGG ou libopenmpt para tracker music
single-file publish
ZIP portátil
assinatura depois

Por quê?

Porque você lança rápido e mantém controle.

Versão 2: diskmag audiovisual

Godot
JSON/BBCode
AudioStreamPlayer
shader CRT discreto
export Windows
PCK embedded ou zip com PCK

Por quê?

Porque fica mais “obra digital” e menos “app”.

Versão 3: diskmag/webzine híbrida

Tauri
Svelte ou vanilla JS
Markdown -> HTML
howler.js
NSIS setup.exe

Por quê?

Porque reaproveita quase tudo na web.

27. O melhor plano prático

Semana 1: protótipo

escolher WPF ou Godot;
criar tela de abertura;
criar menu;
carregar 3 artigos;
música mute/unmute;
créditos;
exportar .exe.

Semana 2: conteúdo real

escrever 8 a 12 textos;
criar capa;
criar direção visual;
organizar assets;
testar leitura.

Semana 3: polish

transições;
busca simples;
fullscreen;
ícone;
splash;
build release;
ZIP;
SHA256;
página de download.

Semana 4: distribuição

assinatura se fizer sentido;
release no GitHub/itch/site;
mirror;
post de lançamento;
versão HTML/PDF paralela.

28. Checklist técnico da v1

[ ] abre sem instalar
[ ] funciona offline
[ ] não pede admin
[ ] tem README
[ ] tem licença/créditos
[ ] tem mute
[ ] tem fullscreen/windowed
[ ] tem saída clara
[ ] tem hash SHA256
[ ] não baixa código remoto
[ ] não escreve em pasta sensível
[ ] conteúdo fonte está preservado
[ ] build é reprodutível
[ ] foi testado em Windows limpo

29. Checklist editorial da v1

[ ] tem título forte
[ ] tem número da edição
[ ] tem editorial
[ ] tem sumário
[ ] tem créditos
[ ] tem data
[ ] tem versão
[ ] tem 8-12 textos reais
[ ] não é só demo técnica vazia
[ ] tem motivo para existir como EXE

A pergunta mais importante:

Se eu remover música, animação e menu, ainda sobra uma boa publicação?

Se a resposta for não, você não tem diskmag. Você tem skin.

30. Exemplo de estrutura final

MuradDiskmag01/
  README.md
  LICENSE.md
  CHANGELOG.md

  issue/
    meta.yaml
    cover.md
    articles/
      001-editorial.md
      002-manifesto-terminal.md
      003-bbs-e-ritual.md
      004-arquivo-vivo.md
      005-notas-de-laboratorio.md

    assets/
      images/
      audio/
      ansi/
      fonts/

  src/
    MuradDiskmag/
      MuradDiskmag.csproj
      App.xaml
      MainWindow.xaml
      Core/
      Views/

  tools/
    build_content.py
    pack_assets.py
    hash_release.ps1

  release/
    MuradDiskmag01.exe
    MuradDiskmag01.zip
    SHA256SUMS.txt

31. Formato de `meta.yaml`

id: murad-diskmag-001
title: "Murad Diskmag #001"
subtitle: "The Archive Is Alive"
version: "0.1.0"
date: "2026-06-22"
editor: "Pablo Murad"
language: "pt-BR"
resolution:
  width: 1280
  height: 720
theme:
  palette: "ansi-dark"
  font: "PxPlus IBM VGA"
audio:
  default_volume: 0.35
  tracks:
    - id: intro
      file: "assets/audio/intro.xm"
articles:
  - id: "001"
    title: "Editorial"
    file: "articles/001-editorial.md"
  - id: "002"
    title: "Manifesto do Terminal"
    file: "articles/002-manifesto-terminal.md"

32. Exemplo de `article.md`

---
id: "002"
title: "Manifesto do Terminal"
author: "Pablo Murad"
section: "Manifestos"
tags: ["terminal", "bbs", "arquivo"]
music: "intro"
---

# Manifesto do Terminal

A web ficou lisa demais.

O terminal devolve atrito, presença e escolha.

33. Publicação paralela

Não publique só o .exe.

Publique também:

- versão HTML
- versão PDF
- versão TXT/Markdown
- screenshots
- vídeo curto
- checksum

Isso resolve três problemas:

Preservação.
Confiança.
Acesso para quem não roda .exe.

A diskmag executável é o ritual.
HTML/PDF é a preservação e o alcance.

34. Caminho mais elegante

Se eu fosse desenhar a stack final com bom senso:

Fonte:
  Markdown + YAML frontmatter

Build:
  script Python/Node para gerar issue.json + content.pak

App v1:
  C# + WPF ou Avalonia

App v2 experimental:
  Godot audiovisual

Distribuição:
  ZIP portátil + SHA256
  Setup assinado quando amadurecer

Arquivo:
  HTML/PDF/Markdown no site

Isso é centrado porque separa:

conteúdo
engine
arte
distribuição
preservação

O erro seria misturar tudo em um monstro.

35. Veredito

Hoje, criar uma diskmag Windows .exe é perfeitamente viável.

Mas o caminho inteligente não é copiar 1997 literalmente.

O caminho inteligente é:

usar tecnologia moderna
manter o ritual antigo
preservar o conteúdo fora do binário
distribuir com segurança
assinar quando possível
criar uma experiência que justifique ser executável

Minha recomendação final:

Para a primeira Murad Diskmag: faça em C# + WPF/Avalonia, com artigos em Markdown, assets empacotados, música opcional e ZIP portátil.
Para uma edição mais artística: faça uma versão em Godot.
Para versão web/desktop híbrida: use Tauri.

Não comece pelo motor perfeito. Comece por uma edição pequena, fechada e boa.

Uma diskmag ruim com engine incrível continua ruim.
Uma diskmag boa com engine simples ainda funciona.