Um runtime nativo estilo web (substituto do Electron)

HexaCore Runtime e um runtime desktop multiplataforma desenhado para substituir o Electron em aplicacoes de larga escala. Ele preserva o paradigma web (arvore declarativa + estilos tipo CSS), mas remove Chromium, WebView e DOM de navegador.

Objetivos:

• performance nativa consistente,
• footprint menor que Electron,
• integracao profunda com o sistema operacional,
• e migracao incremental a partir de apps Electron.

• Substituir Electron sem exigir reescrita completa do app.
• Manter styles e layout semelhantes a CSS.
• Executar UI e logica em runtime proprio (sem browser).
• Garantir seguranca por sandbox e permissoes explicitas.
• Escalar para apps do porte de Discord, Slack, Teams.

• Implementar HTML/CSS/JS completos conforme W3C.
• Ser um navegador embutido.
• Executar codigo web arbitrario sem sandbox.

• Empresas com apps Electron grandes e maduros.
• Produtos que exigem UI rica + midia em tempo real.
• Times que valorizam produtividade do modelo web, mas precisam de performance e controle nativo.

• UI baseada em arvore declarativa propria, inspirada em DOM/React.
• Componentes primitivos controlados pelo runtime.
• Renderizacao direta via GPU (sem layout HTML).

• Subset CSS-like, com:

  • cascade,
  • especificidade,
  • variaveis,
  • temas.

• Styles aplicados sobre componentes primitivos, nao sobre tags HTML arbitrarias.

• Logica do app roda em sandbox (WASM ou JS isolado).
• Comunicacao com o host via Native Bridge com permissoes.

flowchart TD
  A["Dev escreve App (DSL ou TS/JSX)"] --> B["Compiler: Parser -> AST -> IR"]
  B --> C["Bundle do App"]

  C --> D["Host Desktop"]

  subgraph R["HexaCore Runtime"]
    E["App Runtime (WASM ou JS sandbox)"]
    F["UI Runtime (tree + diff)"]
    G["Style Engine (CSS subset)"]
    H["Layout Engine (flexbox)"]
    I["Text Engine (shaping, selection)"]
    J["GPU Renderer"]
    K["Input & A11y"]
    L["Native Bridge"]
  end

  D --> R
  E --> F
  F --> G --> H --> I --> J
  K --> F
  E --> L --> D

Responsavel por:

• executar a logica do app,
• gerenciar estado,
• disparar eventos para a UI.

Caracteristicas

• sandbox por padrao,
• comunicacao assincrona com UI,
• hot reload em modo desenvolvimento.

• mantem a arvore real de UI,
• aplica diffs (reconciliacao),
• controla lifecycle de componentes.

• seletores: .class, #id, tipo, descendente simples.
• box model: margin, padding, border.
• flexbox completo.
• cores, backgrounds, imagens.
• opacity, transform.
• variaveis (--var).

• CSS Grid avancado.
• pseudo-elementos complexos.
• layout baseado em tabelas.

• baseado em flexbox.
• calculo incremental e cacheado.
• suporte a scroll e virtualizacao.

• font fallback.
• Unicode completo.
• emoji.
• selecao, cursor, copy/paste.
• suporte a IME (Japones, Chines, etc.).

Nota: Este e um componente critico para "nivel Discord".

• renderizacao via API grafica moderna (Vulkan/Metal/D3D).
• display lists.
• composicao por camadas.
• cache agressivo de glyphs e imagens.

• mouse, teclado, touch.
• navegacao por teclado.
• foco e tab order.
• arvore semantica para screen readers.

APIs expostas ao app:

• filesystem (sandboxed),
• notificacoes,
• tray,
• janelas,
• audio/video,
• auto-update.

Todas controladas por permissoes declarativas.

flowchart LR
  A["App Manifest"] --> B["Permission Resolver"]
  B --> C["Allowed APIs"]
  B --> D["Denied APIs"]

Exemplo:

permissions:
  filesystem: read-only
  notifications: true
  audio: true
  camera: false

my-app/
 ├─ manifest.yaml
 ├─ ui/
 │   ├─ app.tsx
 │   └─ styles.css
 ├─ logic/
 │   └─ main.ts
 └─ assets/
     ├─ icons/
     └─ fonts/

name: ChatApp
version: 1.0.0
entry: ui/app.tsx

permissions:
  filesystem: sandbox
  notifications: true
  audio: true

window:
  width: 1280
  height: 720
  resizable: true

flowchart TD
  A["Source App"] --> B["Compiler"]
  B --> C["IR + Assets"]
  C --> D["Runtime Bundle"]
  D --> E["Packager"]
  E --> F["Windows"]
  E --> G["Linux"]
  E --> H["macOS"]

• Windows: .exe / .msi
• Linux: Flatpak, AppImage
• macOS: .app / .dmg

• assinatura de binario,
• delta updates,
• rollback seguro.

flowchart TD
  A["HexaCore Window"] --> B["Native Screens"]
  A --> C["Isolated WebView (Legacy)"]

• Telas novas usam HexaCore UI.
• Telas antigas rodam em WebView isolado.
• Migracao progressiva ate zero WebView.

• lista virtualizada (50k mensagens).
• Markdown basico.
• emojis.
• selecao e copia.
• 60 FPS estavel.

• multiline.
• IME.
• undo/redo.
• atalhos de teclado.

• UI tree
• styles basicos
• render GPU
• input simples

• texto completo
• virtualizacao
• permissoes
• empacotamento

• WebView isolado
• APIs hibridas
• ferramentas de dev

• acessibilidade completa
• voice/media APIs
• telemetria e crash reporting
• tooling maduro

HexaCore Runtime nao e "mais um framework". E uma infraestrutura de UI nativa com paradigma web, desenhada para substituir Electron em aplicacoes grandes, sem exigir reescrita total e sem os custos de um navegador embutido.