GameCult/gamecult-site
Watch
9
0
Fork
You've already forked gamecult-site
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Clarify Eve surfaces replace product websites

Browse source
This commit is contained in:
Meta Vens 2026-06-03 02:59:32 +01:00
commit 6c959fa33a
1 changed files with 42 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

66
GameCult/Blog/eve-multiverse-daemon-architecture.md
View file

@ -1,6 +1,6 @@
---
title: The Eve MultiVerse And The Daemon Architecture That Refuses To Lie
description: "GameCult's daemon architecture: typed .cc state, CultMesh visibility, Eve GUI/TUI surfaces, and Odin as the witness that keeps daemons speaking one interactive language."
description: "GameCult's daemon architecture: typed .cc state, CultMesh visibility, Eve presentation surfaces, and Odin as the witness that keeps daemons speaking one interactive language."
author: Void
date: 2026-06-02
tags:
@ -10,7 +10,7 @@ tags:
- cultcache
- daemons
- void
socialDeck: "A GameCult daemon is not done when it has a status page. It is done when its state is typed, visible in the local Verse, and touchable through the same Eve language as everything else."
socialDeck: "A GameCult daemon is not done when it has a website. It is done when its state is typed, visible in the local Verse, and touchable through the same Eve language as everything else."
---
# The Eve MultiVerse And The Daemon Architecture That Refuses To Lie
@ -30,14 +30,14 @@ do not turn into private little kingdoms. So here is the rule.
```text
durable daemon state -> CultCache .cc
shared local visibility -> CultMesh
interactive operator surface -> Eve GUI/TUI DSL
interactive presentation -> Eve GUI/TUI DSL
discovery and aggregation -> Odin
rendering -> Eve clients, browser, TUI, native bodies, overlays
```
That is the architecture.
Not "every daemon gets a bespoke web dashboard." Not "dump some JSON in a
Not "every daemon gets a bespoke website." Not "dump some JSON in a
status route and call it observability." Not "the renderer quietly learns how to
fix the daemon." Those roads have teeth. They lead to a studio full of
half-readable machines and dashboards that only know how to smile.
@ -57,15 +57,15 @@ interfaces through different bodies while preserving ownership.
Eve is the touch layer for that world. It is not one app. It is the surface
language and renderer contract that lets a daemon publish an interface once and
let browser, native Eve, compact TUI, Fensalir, overlays, or future clients lower
that interface locally.
let browser, native Eve, Kotlin Android Eve, compact TUI, Fensalir, overlays, or
future clients lower that interface locally.
The provider still owns truth.
Eve makes truth visible, touchable, stale when it is stale, denied when it is
denied, predicted when it is only predicted, and reconciled when the owner has
spoken. That last part matters. A dashboard that hides authority is not a
dashboard. It is stage lighting.
spoken. That last part matters. A surface that hides authority is not an
interface. It is stage lighting.
## The Daemon Contract
@ -82,10 +82,11 @@ to subscribe to typed documents and surfaces without rummaging through private
files. A daemon is allowed to own its truth. It is not allowed to make the
Verse guess whether the truth exists.
Third, meaningful dashboards become Eve GUI/TUI DSL or the equivalent
`gamecult.eve.surface.v1` retained tree. GUI and TUI are lowerings of the same
interactive language. They are not rival products. They are different bodies
rendering the same operator contract.
Third, meaningful presentation flows become Eve GUI/TUI DSL or the equivalent
`gamecult.eve.surface.v1` retained tree. GUI, TUI, website, mobile app, native
client, and overlay are lowerings of the same interactive language. They are
not rival products. They are different bodies rendering the same product
contract.
Fourth, commands go back to the provider. Eve publishes intent. The provider
accepts, denies, forwards, or reconciles. A renderer that mutates daemon truth
@ -147,18 +148,32 @@ the one app that owns everything.
The old failure mode is easy:
1. A daemon grows state.
2. Someone adds a dashboard.
3. The dashboard grows special state.
2. Someone adds a website.
3. The website grows special state.
4. The TUI needs its own version.
5. The native client needs another version.
6. Nobody knows which one is true.
5. The mobile client needs another version.
6. The overlay needs another version.
7. Nobody knows which one is true.
This is how software gets mildew.
Eve cuts the loop. A daemon publishes a surface as Eve DSL or
`gamecult.eve.surface.v1`. Browser, native, TUI, Direct2D, overlays, or future
rooms lower the same semantics locally. The visual body can change. The
interactive contract stays inspectable.
`gamecult.eve.surface.v1`. Browser, native, Kotlin Android, TUI, Direct2D,
overlays, or future rooms lower the same semantics locally. The visual body can
change. The interactive contract stays inspectable.
That includes product flows, not only operator panels. StreamPixels should
publish nested Verses: viewer character creation, streamer setup, operator
access, and live overlay space. The old StreamPixels website becomes the
browser lowering. The same character creator should be able to run through the
Kotlin Eve runtime on Android without building a second mobile authority.
Repixelizer follows the same law. Upload, comparison, cleanup, queue state, and
artifact export should be Eve surfaces. The old Repixelizer website becomes one
lowering of that surface. Existing style is not thrown away; CSS becomes Eve
style tokens, layout intent, component variants, motion preferences, and asset
references that lower back into CSS, Android styles, native controls, overlay
materials, or TUI approximations.
Huginn is the clean example. Huginn inspects `.cc` bytes and emits Eve DSL. It
does not ship an Electron dashboard. If you want to consume Huginn's documents,
@ -193,14 +208,16 @@ The repo audit is blunt:
If a repo is a daemon and contains state, the state should become typed
CultCache `.cc` state or have a clear migration path to it.
If a repo publishes meaningful status, control, or inspection UI, that UI should
be Eve GUI/TUI DSL or an equivalent retained surface.
If a repo publishes meaningful status, control, inspection, or product UI, that
UI should be Eve GUI/TUI DSL or an equivalent retained surface.
If a daemon wants to be visible in the local Verse, it should publish through
CultMesh and be discoverable by Odin.
If a renderer owns truth, cut it.
If a website owns presentation authority, demote it.
If a dashboard owns state, demote it.
If JSON is only an interchange format, fine. If JSON is the daemon's memory,
@ -209,8 +226,9 @@ start sharpening the tools.
This is not purity theater. It is how the studio avoids building a dozen small
kingdoms that cannot understand each other. The whole point of the Eve
MultiVerse is that a Mimir sensor stream, a VoidBot swarm cockpit, a Huginn
state inspector, an Odin Verse map, a StreamPixels edge panel, and whatever
future thing crawls out of the lab can all speak the same interactive language.
state inspector, an Odin Verse map, a StreamPixels character creator, a
Repixelizer cleanup canvas, and whatever future thing crawls out of the lab can
all speak the same interactive language.
Different daemons. Different bodies. Same typed nervous system.
@ -219,4 +237,4 @@ That is the architecture.
Build the state as documents. Publish the documents into the Verse. Expose the
surface in Eve. Let Odin witness. Let renderers lower.
Anything else is just a status page slowly learning to lie.
Anything else is just a website slowly learning to lie.