#OMN — Open Media Network
The #OMN technical framework provides a modular, standards-based foundation for building distributed media networks that can interconnect without centralized control. It combines open protocols such as ActivityPub, RSS/Atom, and JSON-API to enable content sharing and discovery across diverse platforms while maintaining local autonomy. Each OMN node functions as an independent instance with its own data store, moderation settings, and trust relationships, all defined within a flexible trust flows that governs how information flows between peers. Designed around the #4opens principles — open data, code, standards, and process — the #OMN framework emphasizes interoperability, resilience, and transparency. It provides developers with a clear structure for extending functionality through APIs, plugins, and peer-to-peer integrations, forming the technical backbone for a genuinely open and federated media ecosystem.
https://hamishcampbell.com/dev-test-work-for-makinghistory-application/
Technical Overview (engineering focus)
Core Concept - The Open Media Network (#OMN) is a distributed content syndication and discovery system designed to connect independent media sources via open standards. It enables the sharing, indexing, and republishing of media across multiple platforms and instances without central control.
System Architecture a. Nodes (Instances). Each OMN node is an independently operated instance that: Hosts its own content database. Exposes metadata and feeds via open protocols. Optionally mirrors or republishes trusted external content.
Data Layer. Storage: Flexible - supports local file systems, object stores (e.g., S3-compatible), or databases (PostgreSQL, SQLite). Format: Standardized content metadata schema (JSON-LD maybe?). Versioning: Content version tracking via content hashes (e.g., Git or IPFS-style).
Communication Layer. Primary transport options: ActivityPub for federation and interoperability with Fediverse platforms. RSS/Atom for backward compatibility with legacy syndication. JSON-API / REST endpoints for programmatic access.
Future integration: Dat/Hypercore, nostor, IPFS, or Solid pods for peer-to-peer persistence.
Trust and Moderation System. Each node maintains a trust list for other nodes and content sources. This defines syndication permissions and visibility scope. Switches / Configuration. Each instance can toggle: Open (accept all incoming content). Moderate (review incoming before publish). Closed (publish only local content). Defaults can be set per-instance or per-feed.
Content Flow. Ingestion: Nodes import local or remote media via ActivityPub, RSS, or direct submission. Metadata normalized to internal OMN schema.
Indexing: Content indexed by tags, origin, timestamp, and trust weight. Optional full-text search via ElasticSearch or MeiliSearch.
Distribution: Syndicated out via ActivityPub or RSS feeds to peers. Local curation layers (collections, playlists, tags) allow remixing or aggregation.
Display / Output: Front-end options: Static website generator (e.g., Eleventy, Hugo). Dynamic interface tink tweetdeck. Embeddable widgets for remote inclusion.
Data Model. Field Type Description id UUID Unique content identifier origin URI Source instance or author title String Content title summary Text Short description body HTML/Markdown Main content tags Array Keywords for categorization Publish time license URI Open license reference media_attachments Linked media files
The #makeinistory tech is about creating tools and protocols that keep stories alive, portable, and connected across the #openweb. It builds on the same foundations as the #OMN — open data formats, federation standards, and trust-based networks — but with a focus on preserving and linking narratives rather than just media. Each story becomes a node in a living web of context: traceable, remixable, and shareable without central control. By using open metadata and versioning, #makeinistory allows people and communities to document change, connect events, and maintain continuity over time — ensuring that independent voices, projects, and histories can be told, found, and built upon long after the platforms have faded.
The #indymediaback tech stack is designed as a lightweight, modular reboot of the original Indymedia infrastructure — updated for the distributed #openweb era. Built around the #OMN (Open Media Network) protocols, it provides a federation-ready publishing platform where each local collective can host, moderate, and syndicate their own media while remaining interoperable across the network. Using open standards like ActivityPub, RSS/Atom, and JSON-API, it enables stories, video, and photo posts to flow between trusted nodes without central control. Each instance has configurable “open/moderate/closed” trust switches, allowing collectives to define how content is shared and remixed. In practice, this brings back the classic Indymedia principle of “publish then filter,” reimagined with modern distributed tools to support resilience, autonomy, and collaboration across independent media spaces.
The #OGB (Open Governance Body) fits into the #OMN as the governance layer that manages decision-making and coordination across the distributed network — built with the same open, modular, and federated principles as the tech itself.
Technically, the #OGB can be understood as a protocol and set of software tools for decentralized governance. It defines how different instances (projects, collectives, media nodes) can propose, deliberate, and ratify shared actions without central authority. This is achieved through lightweight consensus and trust mechanisms — reputation, affinity, and open audit trails — all interoperable through standard APIs.
Each #OGB instance can run locally or federate with others to form interconnected governance clusters, allowing for decisions to be made transparently and accountably across the network. Governance processes can evolve without fragmentation — groups can diverge while still maintaining technical compatibility and communication.
In short, the #OGB is to governance what #OMN is to publishing: a decentralized, extensible framework built on open standards. Together they form a form a part of a technical and social stack — open media (OMN) and open governance (OGB) — enabling a living, trust-based network to coordinate, publish, and evolve in a federated ecosystem.