OpenEarth Messenger

Modular Trixnity-based platform for rendering foundation.protocols.* Matrix events as native Compose UI timeline elements. Part of the OpenEarth Network.

A separate bridge component emits events. This messenger renders them. They communicate via the Matrix wire format (JSON), not shared JVM classes.

Quickstart — pull main + run locally

For the impatient: clone, run, see the app in 3 commands.

# 1. Clone (or `git pull` if already cloned)
git clone https://git.vake.works/OpenEarthNetwork/openearth-messenger
cd openearth-messenger

# 2. Run the desktop app (Linux / macOS / Windows; native gradle path)
./gradlew :openearth-app:run

That opens the Compose Desktop app — login screen → room list → timeline. JDK 21 is the only host prerequisite (gradle wrapper handles everything else). First run downloads ~3 GB of deps (~5-10 min); subsequent runs are seconds.

About → Imprint carries the AGPL §13 source-availability disclosure; About → Licenses lists every transitive dep + their licenses (153 libraries; cleanup #80 fix landed 2026-06-01).

Packaged Linux .deb, Android, iOS, and Web distributions are in progress.

Logo: The Living Pangea Network

The OpenEarth logo is generative and evolving — it changes with each release. The logo depicts Pangea (the supercontinent from 225 million years ago, when all landmasses were united) overlaid with a federation network of colourful binary digits (0s and 1s) in the five VakeWorks Transparency Pledge colours.

Why Pangea?

225 million years ago, all of Earth's land was one connected mass — Pangea. Every continent we know today was part of this single whole. Over deep time, the land drifted apart into the separate continents we see now, divided by vast oceans.

The OpenEarth network reverses this drift. Through the Matrix protocol, sovereign data communities — separated by organisational, jurisdictional, and geographic boundaries — reconnect into a federated whole. Data stays home on each community's own homeserver, but knowledge, insights, and governance flow across boundaries through foundation.protocols.* events. Pangea is the aspiration: one connected earth, respecting the sovereignty of each part.

The continental boundary lines visible within Pangea (traced from the Jurassic period, when the rifting began) serve as the network backbone — the same fractures that will eventually separate the continents are, for now, the pathways that connect them. In the logo, these boundaries become the federation network lines.

Why binary 0s and 1s?

The colourful digits represent data — the foundation of the Data & AI Commons. They come in two sizes:

• Large 0s and 1s (14 nodes) represent major federation homeservers — the infrastructure that sovereign communities run on their own terms.
• Small 0s and 1s (70 nodes) represent local communities, co-operatives, farmers, lawyers, researchers, and individuals — the people who generate, share, and benefit from the commons.

Together they form the "any scale federation" vision: from a laptop running a personal homeserver to a continental data commons, every participant is a node in the same network. The small-world network topology — sparse local connections plus random long-range shortcuts crossing the oceans — mirrors how real federated communities work: dense local collaboration with strategic cross-border partnerships.

Why the five Transparency Pledge colours?

Each 0 and 1 is coloured in one of the five pillars of the VakeWorks Transparency Framework:

Colour	Pillar	Hex	Meaning
Green	Ecological	#00e000	Promotes biodiversity and sustainable practices
Gold	Income	#e0a000	Ensures fair compensation and price understanding
Magenta	Produce	#e040c0	Connects consumers to growers and methods
Cyan	Process	#00c0a0	Highlights unique processing methods and benefits
Blue	Profits	#0080e0	Shows equitable profit distribution

Each colour appears equally — 2 zeros and 2 ones among the large nodes, distributed evenly among the small nodes. The colours are spatially dispersed so that no two adjacent nodes share the same colour, reflecting the diversity of the communities in the commons.

Why generative?

Each release of OpenEarth Messenger regenerates the network layout with a different random seed, producing a unique arrangement of 0s and 1s while keeping the same Pangea base. This makes the logo an untrademarkable trademark — the identity is the concept (Pangea + binary network + transparency colours), not any single fixed image. True open source means the brand itself is open. No one can own the logo; everyone can generate their own version.

Earth is in Space

The globe floats in the darkness of space, with a few stars — some of which twinkle. This is a reminder that Earth is precious, a small blue-brown sphere in the vastness of the universe, part of the solar system, the Milky Way, and the cosmos beyond. The OpenEarth network exists to serve the communities on this one planet we share.

Generate a new logo

The generative logo tool is maintained by VakeWorks; the current release's rendered assets live in assets/.

Design elements

• Pangea continent outlines traced from Wikipedia's public domain Pangaea_continents.svg
• Brown/tan landmasses on blue ocean — natural earth-from-space palette
• Dark space background with twinkling 4-point stars (CSS-animated in SVG)
• 5 Transparency Pledge colours for all binary digit nodes
• 14 large nodes: major federation homeservers, at least 1 per continent, proportional to area
• 70 small nodes: local communities and co-ops, uniformly distributed across all continents
• Small-world network edges: sparse local connections + random long-range shortcuts crossing oceans between continents

Architecture

openearth-messenger/
├── foundation-protocols-events/         # Event definitions ONLY (no UI)
│   ├── information-symmetry/            #   13 supply-chain event classes
│   │   ├── InfoSymmetryEventContent.kt  #     All event @Serializable data classes
│   │   └── EventMappings.kt             #     Koin module + EventContentSerializerMappings
│   └── data/                            #   4 data-commons event classes
│       ├── DataEventContent.kt          #     All event @Serializable data classes
│       └── EventMappings.kt             #     Koin module + EventContentSerializerMappings
│
├── foundation-protocols-views/          # ViewModel + Compose View per domain
│   ├── information-symmetry/            #   Supply-chain timeline views
│   └── data/                            #   Data-commons timeline views
│
├── app-branding/                        # Shared white-label branding contract
├── role-detection/ + farmer-role/ +     # Role stack (actor-role resolution +
│   eu-operator-role/ + messenger-app/   #   per-role UI shells + Tier-2 aggregation)
│
├── openearth-app/                       # The OpenEarth Messenger app
│   ├── Main.kt                          #   Entry points (desktop jvm + browser wasm)
│   ├── OpenEarthConfiguration.kt        #   Module selection + homeserver config
│   └── OpenEarthTheme.kt                #   Brand colours (Material 3)
│
└── integrationtests/ + test-utils/      # Cross-module tests + shared fixtures

Module Catalog

Event Modules

Module	Namespace	Events	Status
information-symmetry	foundation.protocols.information.symmetry.*	13 (of 15 canonical)	SHIPPED CORE (with data)
data	foundation.protocols.data.*	4	SHIPPED CORE (with information-symmetry)

Further domain families are developed privately and join this repo when they mature into a dogfooded need.

Tech Stack

Dependency	Version	Notes
Kotlin	2.3.10	KMP (JVM target)
Trixnity SDK	5.4.0	de.connect2x.trixnity (GitLab Maven)
Trixnity Messenger	4.4.0	de.connect2x.trixnity.messenger (GitLab Maven)
Compose Multiplatform	1.10.1	Desktop + material3
Koin	4.1.1	Dependency injection
kotlinx-serialization	1.10.0	JSON serialization
Ktor	3.4.0	HTTP client (OkHttp engine on JVM)
Gradle	9.3.1	Wrapper included

Build & Run

Prerequisites

• JDK 21. Verify with java -version.
• Git with this repo cloned.
• ~3 GB disk for gradle wrapper + dependencies (cached after first build).

Native gradle (cross-platform; Linux / macOS / Windows)

# Build all modules (compiles + runs the multiplatform test suite)
./gradlew build

# Launch the desktop app (opens login screen → room list → timeline)
./gradlew :openearth-app:run

# Build just the app (faster smoke than full :build)
./gradlew :openearth-app:assemble --no-configuration-cache

# Help + task list
./gradlew tasks --all

The gradle wrapper downloads Gradle on first run (~140 MB; ~30 s – 2 min depending on network). Subsequent runs use the cache.

First launch flow (inside the app):

• Enter homeserver URL (default: matrix.org)
• Login with username + password
• Rooms sync; navigate to a room where a bridge has emitted foundation.protocols.* events — they render with native Compose views (SessionCard, ChatBubble, ToolCallCard, etc.) instead of raw JSON.

Alternative — wasm-js in browser (zero-install):

./gradlew :openearth-app:wasmJsBrowserDevelopmentRun
# Then open http://localhost:8080 (Chromium-family browsers recommended)

There is also a containerised production build + nginx serve recipe under openearth-app/docker/.

Troubleshooting

• Kotlin daemon OOM-killed: give the build ≥ 8 GB RAM. The Kotlin compile daemon requests -Xmx6g.
• Gradle wrapper download stalls: network issue; check proxy / VPN. The wrapper downloads from services.gradle.org. Cached after first success.

White-Label Client Apps

Each client messenger is a thin configuration function (~30 lines):

// example tenant-app/src/.../TenantConfiguration.kt
fun MatrixMultiMessengerConfiguration.tenantConfiguration() {
    appName = "Tenant Messenger"; appId = "org.openearth.reference.messenger"
    modulesFactories += listOf({ composeViewModule(null) }, ::tenantThemeModule)
    messengerConfiguration {
        defaultHomeServer = "matrix.example.org"
        modulesFactories += listOf(
            { composeViewModule(this) }, ::tenantThemeModule,
            ::infoSymmetryEventsModule, ::infoSymmetryViewModelsModule, ::infoSymmetryViewsModule,
            ::dataEventsModule, ::dataViewModelsModule, ::dataViewsModule,
        )
    }
}

The startMultiMessenger DSL from trixnity-messenger provides login, rooms, timeline, settings, E2EE, and multi-profile support. Client apps only configure: branding (*ThemeModule), domain modules (which foundation.protocols.* events to enable), and homeserver defaults.

Testing

# Full multiplatform test suite (all modules; jvm + js + wasm targets)
./gradlew build

# JVM-only, faster inner loop
./gradlew jvmTest

# Cross-module integration tests (mokkery mocks; JVM-only module)
./gradlew :integrationtests:jvmTest

Design Docs

• White-labelling guide: docs/white-labelling.md
• Known build/toolchain issues: KNOWN-ISSUES.md

License

Split licensing to match the Trixnity dual-licensing model:

Module	License	Why
foundation-protocols-events/	Apache 2.0	Protocol spec — depends only on trixnity-core (Apache 2.0). Freely reusable.
foundation-protocols-views/	AGPL 3.0	Depends on trixnity-messenger (AGPL 3.0)
openearth-app/	AGPL 3.0	Depends on trixnity-messenger-compose-view (AGPL 3.0)

Upstream dependencies:

• Trixnity SDK (de.connect2x.trixnity): Apache 2.0
• Trixnity Messenger (de.connect2x.trixnity.messenger): AGPL 3.0 (or commercial license from connect2x GmbH)

For proprietary client deployments, contact VakeWorks (https://vake.works).