Something that’s worth saying out loud: many of the people currently talking for the #Fediverse had very little to do with the generation that seeded this version. That doesn’t automatically make what they say wrong. But it does mean we should be careful about building strategy around their narratives.
A lot of the early Fediverse energy came from the older #openweb traditions of hacker and #FOSS culture, experiments in federated infrastructure and grassroots publishing networks. The long history of things like RSS feeds, blogging, and projects like #indymedia
The #Fediverse didn’t appear out of nowhere, it grew from decades of experimentation with open protocols, decentralised communication, and commons-based infrastructure. Some of the current commentators arrived after the current seeds had already been planted. That’s normal, every movement eventually attracts interpreters, professionalisers, and institutions. But it does mean there is a risk that the story gets rewritten in ways that lose the original lessons.
One of those lessons is simplicity, the systems that spread tend to follow a basic rule: #KISS – Keep It Simple: Simple protocols. Simple tools. Simple ways for people to publish and connect. When infrastructure becomes complicated – governance layers, funding structures, branding strategies, endless, #NGO mediated theoretical debates – the distance between the actual people and the invisible elitism occupying the space, talking the loudest, grows larger.
The Fediverse itself only exists because a handful of people quietly built working code and released it under #4opens licences. Communities adopted it because it worked, not because it was well marketed, not because institutions endorsed it and not because a conference panel explained its importance.
For projects growing the #openweb, the lesson is straightforward: Don’t get too distracted by who is currently speaking for the ecosystem. Look at flows, what is being built, at what people have used and at what follows the basic principles of the commons. And keep things simple. #KISS is still the best guides we have.
Stepping around the recurring #NGO voices in #openweb debates. To do this the problem we need to compost is our lack of balance, meany of the people talking for us have done the same thing for each generation of the open web and bluntly there “common sense” has always failed as it is not native to the #openweb. These people have no idea that they keep circling this mess, so please try and step around them. Because they talk loudly and consistently, newcomers often assume they represent the ecosystem, they don’t. The practical lesson is simple:
Notice them.
Learn from the patterns of past generations.
Step around them.
Our task is to grow native, functioning, living networks, not to repeat old mainstreaming debates that have consistently led nowhere. In other words: don’t argue with the noise, build around it. Keep the focus on grassroots projects, real communities, and real trust-based infrastructure.
There is a persistent myth pushed in our culture that intelligence – high IQ, academic credentials, elitist education – leads naturally to clear thinking. My organic experience suggests the opposite, what matters is disciplined, skeptical, freethinking curiosity. Without that, intelligence simply becomes a tool for defending whatever assumptions people already hold.
This is one of the reasons many academic environments produce people who are, bluntly, credulous. Not because they lack intelligence, but because the institutional structures around them reward conformity and reputation management far more than genuine curiosity.
Over the last two years I’ve been spending time in and around the university culture in Oxford, participating in discussions, events, and academic life. The experience has been instructive, if in the end frustrating. You would expect a place associated with University of Oxford to be a centre of open intellectual challenge. In practice, it feels like something else: a system that filters, polishes, and reproduces existing assumptions.
This is not universal, some of the hard scientific disciplines still cultivate a form of disciplined skepticism, experiments fail, evidence contradicts theory, so you are expected to question results. The process encourages a narrow but very real culture of doubt, but outside those narrow areas, skepticism to often fades.
Instead, you find intellectual fashion cycles building reputational alliances that push institutional caution based on #blinded ideological signalling. The result can be a strange mix of high intelligence and low #blocking curiosity. People who are good at working inside established frameworks, but much less comfortable questioning the foundations of privilege those frameworks rest on.
This matters for the #openweb and projects like #OMN. I got nowhere here as many of the institutions that might have supported open digital infrastructure – universities, NGOs, research centres – have shifted toward the same #deathcult#mainstreaming#blocking that dominates the wider tech world. Funding cycles shape research priorities, institutional partnerships shape acceptable ideas and career incentives shape what can safely be questioned.
So even where intelligence and resources exist, the culture of disciplined curiosity that drives the needed real innovation is thin if it exists at all. The irony is that the early internet grew out of exactly the same institutions, but with opposite culture. The original World Wide Web ecosystem, the hacker and #FOSS communities, and early grassroots media projects like #indymedia were built by people who combined technical curiosity with deep skepticism about centralised control.
They didn’t wait for institutional approval, they experimented, built #DIY tools that broke things and rebuilt them. That spirit is what projects like #OMN are trying to revive. The goal is not to outcompete corporate #dotcons platforms or impress #NGO academic institutions. The goal is simpler: to build open media infrastructure that communities can use based on small nodes, trust networks and open metadata flows. Simple tools that allow people to publish, share, and connect.
This is a working #KISS approach to rebuilding grassroots media. If the last twenty years of the web have taught us anything, it’s that intelligence alone doesn’t produce healthy systems. You can have brilliant engineers building platforms that clearly undermine democratic communication, it’s the mess that shapes the current #dotcons world.
What makes the difference is curiosity combined with skepticism, the willingness to question the structures that shape our digital lives. Without that, even the smartest institutions drift into the same patterns of credulity and conformity, which is why rebuilding the #openweb is not just a technical project, it’s a cultural one.
Why does it feel like so many people have become intolerant prats? A blunt observation: it increasingly feels like many people today are intolerant prats. And worse, this behaviour has started to feel normal. You see it everywhere. Online discussions collapse quickly into hostility. Small disagreements become unthinking moral #blocking were people retreat into camps where any challenge is treated as an attack.
This isn’t just a social media problem, though the #dotcons have certainly amplified it, it’s a deeper cultural shift. For decades the dominant systems shaping our culture have encouraged competition, individualism, and personal branding. The result is what I often call #stupidindividualism – a worldview where the individual ego becomes the centre of everything. In that environment, disagreement stops being part of learning and becomes a threat to identity, so people react defensively, aggressively or dismissively. What used to be debate becomes performance.
The platform problem is when the #dotcons platforms are designed to amplify this behaviour where algorithms reward outrage, tribal loyalty and moral signalling to push conflict to drive engagement. They do not reward patience, nuance, or curiosity, in other words, they are structurally optimised to turn ordinary people into worse versions of themselves. Over time this becomes cultural habit, people start to assume that hostility is normal conversation.
Another factor is the slow collapse of collective spaces. When communities interact face-to-face, or in smaller trust networks, people have to deal with each other as human beings. Relationships create friction but also accountability. In large anonymous digital environments, those social checks weaken. People become avatars and opinions rather than neighbours, this makes it much easier, “natural” to treat each other badly.
Why this matters for the #openweb. If we are trying to rebuild grassroots media and communication infrastructure, we need to recognise that these cultural habits have already spread into many communities, including the tech and activist spaces that should be alternatives. This is one reason projects fragment so easily as small disagreements spiral, people assume bad faith and thus trust collapses.
You end up with endless internal conflict instead of collective building. This isn’t just a personality problem, it’s the legacy of systems that reward attention and conflict rather than cooperation.
A different path can be grown in projects like #OMN which is partly about rebuilding infrastructure, but they are also about rebuilding culture. The idea is simple: smaller networks, trust-based publishing, open metadata flows and simple tools people can run themselves. A #KISS approach to communication infrastructure.
But technology alone doesn’t solve the deeper issue, what actually makes communities work is something much older and simpler: tolerance and curiosity. The ability to disagree without instantly turning disagreement into war. The ability to assume that the other person might have something worth hearing. Without those habits, no infrastructure – open or closed – will function well for long.
Composting the mess – the current online culture is a mess. A lot of the behaviour we see today is the product of twenty years of #dotcons platform design. But mess is also compost, it shows us clearly what doesn’t work. The next generation of the #openweb has an opportunity to build systems that encourage something better: slower conversation, local trust networks, collective responsibility, shared media infrastructure. Less shouting, more listening.
It won’t magically make people perfect. Some people will still be intolerant prats. But at least we won’t be running the entire communication system of society on platforms designed to encourage it.
This Oxford mess is a shadow of a larger mess. We were told the story of Prometheus: fire stolen from the gods and given to humans – our first real piece of technology. The myth asks a simple question: what do we do with power once we have it?
In democratic society why do we put up gig work and side hustles, endless surveillance platforms pushing algorithmic attention traps, housing crises and climate collapse all pushed by a handful of billionaires controlling huge parts of the economy. Why do we put up with What with the mess of technocratic oligarchy – a system where technological infrastructure concentrates power instead of distributing it?
The #mainstreaming mythology of the tech founder helped this happen. The “visionary genius” narrative around people like Bill Gates, Steve Jobs, Mark Zuckerberg, Jeff Bezos, Peter Thiel and Elon Musk turned corporate executives into cultural heroes. This mess is simply #KISS oligarchy with better marketing.
Even ancient thinkers warned about this. Plato and Aristotle described how societies cycle through forms of power, and how rule by the wealthy tends to serve the wealthy above everyone else. The irony is that many of today’s tech elitists think of themselves as the new aristocracy – the “smartest people in the room” guiding humanity forward.
Yet the future they’ve built is #techshit platform #feudalism with people monitored constantly, economic life mediated by a few #dotcons platforms. Infrastructure owned by private empires and democratic institutions bought out then sidelined.
The tragedy isn’t that technology failed, it is more that we let our technological imagination be captured by oligarchs. Prometheus gave humanity fire so we could build civilization together, not so a tiny #nastyfew tech CEOs can privatise the flame and sell back the light.
The real question isn’t whether technology will shape the future, it’s who controls it.
One of the quiet assumptions built into almost every #dotcons platform is that the user secretly wants to become a #techbro. Not literally, of course, but culturally.
You are expected to optimise yourself by building your “personal brand” to track your metrics. Engage with algorithmic growth loops by understand platforms, feeds, APIs, monetisation tools, creator dashboards. You’re supposed to treat communication as a kind of performance engineering problem.
Most people never asked for this, they just wanted to talk to friends, share ideas, organise communities to publish things that matter. Instead, they got trapped inside systems designed around growth hacking and behavioural manipulation.
This is one of the reasons people are quietly, sometimes timidly, stepping away from the #dotcons, not always loudly, not always politically, but gradually. People feel something is wrong.
But when they look toward the #openweb, the path isn’t always easy either. Too often the tools we build assume something similar – just with a different flavour of geek culture. The user is expected to understand servers, protocols, instances, keys, forks, configuration files, federation quirks. In other words, the user is still expected to become a tech person.
This is the #geekproblem showing up again, if the #openweb is going to be a real alternative, we need to take this seriously. The vast majority of people do not want to be #techbros, sysadmins, protocol engineers or crypto specialists. They want tools that work socially, tools that support community rather than demanding narrow blind identity.
This doesn’t mean hiding the technology. The power of the #openweb comes from openness, the #4opens of open data, open source, open process and open standards. But openness should not mean unfriendly #UX.
The challenge for #FOSS and #openweb projects is to build tools with human-first design: Interfaces that feel welcoming rather than intimidating, workflows that reflect how communities actually organise with systems that support trust and relationships, not optimisation and metrics. We need onboarding that doesn’t require a technical worldview
In short: non-techbro #UX. This doesn’t mean dumbing things down, it means remembering what the web was originally good at, simple tools that let people publish, connect, and collaborate without needing permission or expertise.
Right now there is a real opportunity as people step away from the #dotcons, slowly, unevenly, sometimes reluctantly, but the shift is happening. If the #openweb meets them with only complicated tools and insider culture, they’ll drift back to the platforms they know. If we meet them with simple, social, welcoming infrastructure, the shift becomes something much bigger.
So the question for #FOSS developers is simple: Are we building tools for techbros? Or tools for people? If we want the #openweb to grow, the answer matters.
Twenty years ago the #openweb conversation was simple: build in the open, share the code, grow commons. It wasn’t perfect, but the direction was clear. Now? We talk about “neutral infrastructure” while most energy flows into platforms, APIs, app stores and AI silos owned by the #dotcons. Even many of our own projects quietly depend on their hosting, their identity layers, their distribution channels. We’ve normalised bowing down to closed systems, and we call it pragmatism.
But tech was never neutral, to build open systems is not just a technical preference, it’s a social and ecological choice. It’s a choice for collective flourishing: Open code, open standards, open governance – these are living systems, they circulate knowledge, let communities adapt and compost failure into growth.
Closed systems hoard, they lock knowledge behind terms of service, they centralise power by optimising for extraction. And like any monoculture built on extraction, they eventually rot from within. So here’s the uncomfortable question for us as #FOSS maintainers – Are we feeding the #deathcult every time we design for platform lock-in, accept surveillance funding, or optimise for venture adoption over community resilience, we edge closer to it.
The wider culture is drowning in #stupidindividualism. People are burned out by churn, distracted, cynical. But underneath that noise, the desire for connection, justice and sustainability is still there, the soil. The problem isn’t that people don’t want open, it’s that we’ve stopped seeding it in ways that feel alive.
“Open is life. Closed is death.” If that’s too dramatic, look at the ecosystems: federated systems that self-host and fork survive. Closed platforms collapse when the funding cycle shifts or the CEO sneezes. So what do we need to do?
Build for communities, not exit strategies.
Make governance as open as the code.
Refuse the false neutrality that hides power.
Design for interdependence, not dominance.
Compost the mess, learn from failed projects instead of pretending they never happened.
We don’t need purity politics, we need living systems. If open is life, and closed is death – what are we growing with our commits?
In tech funding, over the last decade, the #EU poured hundreds of millions of euros into the #blockchain mess. The promise has proven to be illusion, we built no working transformation: trustless systems, frictionless governance or new economic layers for Europe. The reality? By any honest social metric, 99.9% of that public funding was poured straight down the drain.
Now we are lining up to do the same with AI. Another wave of hundreds of millions, based on another cycle of hype, feeding frenzy for consultants, startups, and policy conferences. And if we are realistic, 99% of this funding will follow the same path: absorbed into closed, corporate-driven ecosystems with minimal public return, poured down the drain.
In between these two hype cycles, we invested comparatively little in the #openweb and #FOSS. And yet that is where we actually saw meaningful results. Even if we are conservative and say 70% of public funding for #openweb and Free and Open Source Software was wasted, that still leaves 30% that worked. Thirty percent that built tools people use. Thirty percent that created infrastructure that continues to function. Thirty percent that delivered measurable social good.
Compared to less than 0.001% meaningful return from blockchain projects (and that’s being generous), and perhaps 1% from AI funding (also generous), this is an extraordinary success rate. So why aren’t we talking more about this?
The Pattern: Funding the Closed, Ignoring the Commons
The problem is not technology, it’s political economy. Public money is repeatedly funnelled into closed ecosystems. #Blockchain projects were built around proprietary platforms, based on financialisation. They all failed to deliver public infrastructure, most were simply vehicles for extraction.
#AI is following the same pattern. Instead of building public infrastructure rooted in openness, transparency, and shared governance, we are too often simply subsidising closed models and corporate consolidation. The result will be the same: dependency, vendor lock-in, and very little democratic control.
Meanwhile, the #4opens and #FOSS quietly power the world.
Servers run on open-source operating systems.
The web runs on open protocols.
Community platforms run on federated code.
Critical infrastructure depends on open libraries.
And yet funding for these projects remains very marginal, precarious, and treated, if at all, as an afterthought.
Why This Matters
This is not only about waste, it is about direction. We are living in an era of climate breakdown, democratic fragility, and accelerating inequality. Public investment needs to strengthen commons-based infrastructure, not deepen dependency on mess of speculative and corporate-controlled #dotcons. When we fund the #fashionista hype cycles we increase centralisation, reduce public oversight and lock ourselves into closed ecosystems, which hollow out our needed local capacity.
When we fund #openweb and #FOSS we build shared infrastructure, increase resilience, enable local innovation to create tools that can be forked, adapted, and reused. Even a poor 30% success rate in commons-based funding creates compounding social value. Code written once can be reused globally. Infrastructure built openly becomes a foundation others can extend. Knowledge stays in the public sphere.
Closed projects don’t compound in the same way. They expire, pivot, get acquired, and then disappear behind paywalls.
The Incentive Problem
So why does this mess keep happening? Because hype is easier to support than maintenance. The current #mainstreaming is to blind, Blockchain and AI come with glossy narratives of disruption and geopolitical competition. They promise growth, dominance, strategic autonomy. They flatter policymakers with the illusion of being at the frontier.
The #openweb and #FOSS, by contrast, are mundane. They are about maintenance, collaboration, and long-term stewardship. They don’t produce any unicorn valuations, the smoke and mirrors that feed splashy policy headlines. But they work, and in public policy, “working” should be the gold standard.
What We Need to Talk About
We need to keep asking direct #spiky questions about what percentage of publicly funded tech projects remain usable five years later? How many are open, forkable, and independently maintainable? Who owns the infrastructure we are building with public money? And does this investment strengthen the commons or subsidise enclosure? If we measured blockchain funding by long-term public utility, it would be exposed as a massive misallocation at best and fraud at worst. If we measure AI funding the same way in five years, we may reach the same conclusion. We #KISS need structural change:
Default to #4opens – Public funding #KISS should require open licenses, open standards, and transparent governance.
Fund Maintenance – Not just #fashionista projects, but long-term stewardship of critical open infrastructure.
Measure Social Value – Not hype, not valuation, not patents, but actual public use and resilience.
Grassroots tech as seedlings – to be open to real change and challenge in tech.
Support Commons Governance – Fund communities, not more startups.
Why We Need to Act
If we do not challenge the current messy #techshit cycle, we keep pushing ourselves into a future defined by the #dotcons, closed platforms with extractive models. To say this is not anti-technology, it is pro-public infrastructure. The choice is simple, do we keep pouring public money into, closed ecosystems with near-zero public return or invest systematically in the messy, imperfect, but functioning #openweb commons.
The data – even by generous estimates – is clear. Thirty percent real return beats 0.001% every time. We need to stop funding hype, we need to fund what works, and we need to say this loudly, before the next billion euros disappears down the same drain.
If you’ve spent years in #FOSS, you’ve likely developed a strong allergy to vague political language. You care about licenses, reproducibility, and whether something actually runs. Good. That discipline is why free software exists at all.
But here’s the needed uncomfortable question, what if the biggest blocker to the #openweb right now isn’t technical debt – but social debt? And what if “good faith” is not a moral nicety, but a core infrastructure requirement?
The problem is when activism meets the #geekproblem. Anyone who pushes for change – especially against #mainstreaming pressures – develops a recurring relationship with bad faith. You see this when:
Corporate actors adopt the language of openness while enclosing the commons.
Institutions celebrate “community” while centralizing control.
Projects technically comply with openness while culturally gatekeeping participation.
This isn’t new, but the scale is new, in the age of #dotcons, #NGO enclosure is polished, funded, and normalized. Resistance generally fragmented, exhausted, and defensive as years of platform manipulation and extractive models have left people burnt out and cynical. In that climate, good faith is fragile, yet without it, nothing decentralized works. Good faith is infrastructure, decentralized systems cannot rely on coercion at scale. They rely on:
Trust
Transparency
Shared norms
The assumption is that participants are not actively trying to sabotage the commons, as when bad faith dominates, decentralized governance collapses into:
Endless meta arguments
Capture by the loudest actors
Drift toward hierarchy “for efficiency”
Sound familiar? This is why good faith isn’t sentimental, it’s structural. If you’ve ever tried to maintain a FOSS project while navigating trolls, corporate opportunists, and purity politics, you already know this.
To help the #4opens is a practical test, not a vibe. The #4opens framework exists precisely to operationalize good faith. It asks four simple questions of any grassroots tech project:
Is the data open?
Is the source open?
Are the processes open?
Are the standards open?
This extends beyond traditional open data initiatives (often institutional, often cosmetic). It covers the entire ecosystem of a project, not just its outputs. The value is not ideological purity, it’s resilience. When data, code, process, and standards are open:
Capture becomes harder.
Forking remains possible.
Governance can be contested transparently.
Communities can leave without losing everything.
That’s not abstract politics, it’s #KISS survival architecture. Composting the current rot we touch on here is why #OMN exists as a project. We are living in a digital environment thick with enclosure and manipulation were years of bad faith, disempowerment, and algorithmic extraction have created social decay. The instinct of many geeks is to build a cleaner stack and hope people migrate, but the problem isn’t just software, it’s trust collapse.
If the #openweb is to mean anything beyond developer autonomy, it has to support collective storytelling and coordination, not just individual expression. On this path, the #OMN is a shovel, not a cathedral, a way to compost the mess rather than pretend it isn’t there.
The #OMN (Open Media Network) is not a shiny new protocol. It’s deliberately simple: Publish, Subscribe, Moderate, Rollback, Edit. That’s it, no engagement hacks, no growth funnels and no surveillance capitalism. It’s a #DIY, trust-based, human-moderated space, messy, organic, built for communities, not only users. This matters in the era of #climatechaos and social break down, as climate instability accelerates, centralized platforms will align with state and corporate power to prioritize “order” over dissent and optimize for profitability in shrinking margins.
To balance these communities will need coordination without permission, information flows that aren’t algorithmically distorted and infrastructure they can adapt locally, that’s a social demand. If #FOSS remains culturally optimized for the small minority who enjoy living inside the #geekproblem, it will not meet that demand at all. We need to understand that the vast majority do not want to self-host, they do not want to debate licences, they do not want to live inside issue trackers. They want functioning, trustworthy spaces, if we can’t provide that, someone else will – and it won’t be #4opens.
The hard part is working with the empowered disempowered of our #fashionista class. We have a generation trained in #closed systems that reward performative critique over collective construction. On #dotcons platforms and strands of #NGO thinking, people are empowered to disempower others with common sense #blocking of call-out culture, optics over substance and branding over shared process. You get a strange anti-politics, egotistical, individualistic, allergic to long-term responsibility. A culture that critiques power while replicating it. Escaping this dynamic may be uncomfortable, it may get nasty before it stabilizes.
But here are some kinder strategies we can use:
Make contributions obvious and low-drama, clear process reduces ego battles.
Reward maintenance, not only innovation, culture follows incentives.
Default to transparency over suspicion, sunlight reduces paranoia looping.
Design for groups, not influencers, collective accounts, shared moderation, distributed ownership.
Keep it simple (#KISS), as complexity amplifies gatekeeping.
None of this eliminates conflict, but it shifts the terrain from personality warfare to shared work.
An invitation to the sceptics, you don’t need to buy the rhetoric, maybe ask instead does this increase forkability? Reduce capture risk? Does it lower dependence on extractive infrastructure to strengthen collective agency? If the answers are yes, they belong in the #FOSS conversation. The future of the #openweb will not be secured by better branding or cleverer stacks. It will be secured by projects that treat good faith as a design constraint and collective resilience as the goal.
This is not about blinded purity, it’s about durability. We can keep polishing tools for the tiny minority who enjoy living inside the #geekproblem, but, we also need to build infrastructure that ordinary communities can also use to navigate the storms ahead. The invitation stands, pick up a shovel, help compost the mess by build something that gives back more than it extracts.
This matters for #FOSS because as if it remains culturally trapped inside the #geekproblem, it becomes socially irrelevant at the exact historical moment it is most needed. Right now, most #FOSS energy still assumes that if you build complex tools, argue narrowly, and keep everything technically “open,” people will come. But only a tiny minority actually want to live the full-stack geek life: self-hosting, compiling, debating licenses, maintaining infra. That path selects for a personality type. It is not neutral.
The problem isn’t that this path exists, it’s that it quietly tries to define culture. The tension is that the #geekproblem tends to reduce political and social questions to technical architecture. It too often treats freedom as a property of code, rather than a property of relationships. But in an era of #climatechaos, people don’t need abstract freedom in protocol design. They need mutual aid to build trust networks and local resilience. They need collective agency in open spaces to coordinate without corporate capture. These are #KISS social demands.
If #openweb remains framed as a technical alternative to Big Tech, it will only attract geeks and edge cases. If it is framed as a public infrastructure for collective survival, it suddenly matters to everyone. This shift in focus is urgent as climate disruption accelerates: Centralized platforms will prioritize profit and state alignment, infrastructure failures will become normal, feeding political polarization. Authoritarian coordination models will look “efficient.” If #FOSS cannot step outside the geek subculture, it leaves the field open to #dotcons and state/corporate hybrids to define digital coordination. That’s not a tech failure. It’s a social failure.
So, what changes this frameing? To make #openweb meaningful to the majority, we need to shift from tools to practices. Don’t only ask people to install software, ask what they are trying to do with digital tools together. Then lower cultural barriers, not just technical ones, by building code for groups, not only individuals. The mainstream internet optimizes for #stupidindividualism, the alternative needs to be balancing this mess, by optimizing for collectives.
Accept messiness, social systems are not elegant, they compost, they fork culturally before they fork technically. Centre use in crisis, not only ideology, when floods hit, when heatwaves hit, when services fail – what does the #openweb enable that corporate #dotcons platforms cannot? If the answer is “we have a nicer licence,” it won’t matter. If the answer is “your community can coordinate and survive without asking permission,” it becomes essential.
The hard truth is only a minority want to be geeks, but almost everyone wants dignity, voice, belonging and some stability in chaos. If #FOSS and #openweb can’t translate into those terms, they remain culturally marginal. This is why the issue is urgent, not because the code is broken – but because the social imagination around it is too small for the scale of the social and ecological crisis. And in the age of #climatechaos, infrastructure that doesn’t scale socially (#fluffy) will be replaced by infrastructure that scales politically (#spiky) – whether we like it or not.
The question isn’t whether #openweb works, it’s whether it can grow beyond the #geekproblem long enough to matter.
Human Tech: The Open Media Network (#OMN) is a proposal for human-scale, federated media infrastructure built on standard #FOSS practices and the #4opens: open data, open source, open process, open standards.
It does not attempt to invent a new platform. It defines a minimal, interoperable framework for how content flows through networks, in ways that remain understandable, auditable, and governable by the communities that use them.
The core premise is simple, if people cannot mentally model how a system works, they cannot meaningfully govern it. When infrastructure becomes opaque, power centralises.
OMN reduces networked publishing to five irreducible functions. Everything else – feeds, timelines, notifications, dashboards – is interface.
The OMN Framework: The Five Functions (#5F)
Rather than starting from features or products, OMN starts from flows. Think of a network as pipes and holding tanks. Objects move through them, communities decide how. The entire stack reduces to #5F:
1. Link / Subscribe to a Flow
Connection is explicit and user-controlled. A node can link to or subscribe to any flow – local or remote. Flows can be personal, collective, moderated, experimental, or archival. This replaces platform enclosure (“you are inside us”) with composable federation (“this connects to that”).
No built-in opaque ranking algorithms, no engagement manipulation, just declared connections between flows.
2. Trust / Moderate a Flow
Moderation is treated as routing and filtering – not binary censorship. Flows can:
Pass through untouched
Be diverted into holding tanks
Be filtered through community-defined sieves
Be contextualised rather than removed
Trust is local and explicit, different communities can apply different filters to the same upstream source. This preserves plurality while avoiding centralised control.
3. Rollback
Rollback enables recovery without destructive central authority. Communities can:
Rewind aggregation decisions
Remove objects from local flow
Correct moderation mistakes
Recover from abuse or spam
Without rollback, errors escalate into governance crises. With rollback, accountability becomes procedural rather than punitive.
4. Edit Metadata
Objects are not rewritten, they are contextualised, metadata can be appended to content:
Tags
Trust signals
Warnings
Summaries
Translations
Relevance markers
Meaning emerges through socially applied metadata, not engagement-optimised algorithms. This is the backbone of decentralised news curation.
5. Publish Content
Publishing is simply adding an object into a flow. Publication does not imply amplification. Authority is emergent through trust relationships. At the base of all five functions is a simple storage layer, a database holding objects in motion. No proprietary feed logic, its people and community. No built-in opaque AI ranking layer or dependency on surveillance economics.
Why This Matters for Public Digital Infrastructure
Most contemporary social media systems are vertically integrated, identity, distribution, ranking, moderation, monetisation and storage are all coupled inside corporate governance structures. This produces structural centralisation, even when protocols are nominally federated.
#OMN is about functional decoupling by isolating the core five functions, infrastructure becomes auditable, replaceable, forkable, composable and grassroots governable. Complexity is where capture happens, minimalism is a #KISS governance strategy.
Nothing New – By Design
OMN intentionally builds on patterns that already work: Packet-switched networks, electrical grids, plumbing systems, version control systems and federated FOSS collaboration models. This is the #nothingnew principle: sustainable infrastructure mirrors systems humans already understand. When technology reflects intuitive physical systems, governance becomes possible at human scale.
It is not a product, it is a reference architecture and implementation framework. Others are encouraged to build clients, moderation layers, UX experiments, archival tools, research layers, and community governance models in the flow. The value lies not in novelty, but in interoperability and trust-layer experimentation.
OMN aligns with public-interest infrastructure goals:
1. Decentralisation Without Fragmentation
Federated flows with local moderation and shared protocols.
2. Trust Mediation as a First-Class Function
Trust is explicit, inspectable, and socially determined, not hidden inside ranking systems.
3. Lossy by Design
Perfect synchronisation is not required. Redundancy increases resilience.
4. Forkability
Each node can evolve independently without breaking interoperability.
5. Infrastructure Over Platform
OMN is a toolkit for building ecosystems, not a single destination site.
From Indymedia to a Federated Commons
The first seed projects are makinghistory and rebooting early grassroots media networks like Indymedia demonstrated the power of open publishing anyone could contribute, communities moderated collectively and infrastructure was mission-aligned. But back in the day, those systems lacked tech scalable trust layering and sustainable federation paths.
OMN is an attempt to reboot that tradition using contemporary FOSS practice and federated architecture. Not as nostalgia, but as public digital infrastructure.
Interoperability tooling with existing federated systems
Trust-metadata experimentation frameworks
Governance model documentation
Security auditing and resilience testing
Documentation aimed at non-technical community operators
The aim is to lower the barrier to running community-governed media nodes while preserving composability with the broader federated web.
In Summary
The Open Media Network is federated, trust-based, open by design with minimal core architecture built for governance, not engagement capture. It is infrastructure for communities to create their own flows, their own networks, their own moderation models. It is not about optimising users, it is about enabling public agency. Not control, trust.
OMN is not a platform, it is plumbing for democratic digital commons #KISS
Almost all funding in the #openweb space gets absorbed by the mediation layer – the people and organisations who talk about, manage, and frame the work rather than doing it. Some money reaches (#geekproblem) developers. Some supports visible projects and #fashionista careers. But the pattern holds: funding flows to what institutions can understand, and institutions rarely understand messy, unglamorous, day-to-day grassroots work.
So resources pile up around reports, events, strategy documents, coordination roles, and polished narratives – while the people actually running infrastructure, holding small communities together, and doing the labour that sustains the #openweb go unfunded. That’s not usually corruption, it’s structural. Institutions fund what they can measure and present. What they can measure and present is almost never the soil layer.
The result is a widening gap between the #fashionista story of the #openweb and the lived reality of it. More funding grows blinded narratives faster than it grows anything real. The question isn’t just “more money”, it’s how do we get resources to the people actually doing the work?
That’s why strong words matter. Naming parasites gives people who are currently being parasitic a chance to stop. Naming #techshit gives people making it a chance to compost their own mess. If they take that chance, good – a kindness has been done. If they don’t, we compost the mess ourselves and grow something better. #KISS.
“Impossible” Is a Political Word
Slavery abolition was impossible. Universal suffrage was impossible. Worker self-organisation was impossible. An open global communications network outside state control was impossible. Until people acted as if it weren’t.
Calling something impossible is usually political – a way of narrowing imagination and disciplining ambition, keeping demands within what existing power structures can tolerate. Structural shifts rarely begin as reasonable proposals. They begin as overreach. Commons infrastructure, resisting enclosure, building beyond scarcity logic – none of this looks feasible from inside the incentive structures it’s trying to replace.
If we only aim for what seems immediately achievable, we are reinforce existing incentives. If we aim beyond them, we shift the terrain. We may not reach the impossible goal, but we change what becomes possible next. That’s not utopianism. Historically, it’s actually #KISS and it’s how boundaries move.
Open Spaces Attract Parasites. That’s Ecology.
The #openweb generates real value: code, trust, collaboration, legitimacy, cultural capital. None of it is stable without maintenance. When drift sets in, someone has to shovel. That work is messy, exhausting, unpaid, and constant – because digital commons produce nutrients, and institutional actors are trained to harvest nutrients. If nobody composts the shit, the project chokes.
The “parasite class” in tech isn’t made up of evil masterminds. They tend to be institutional, NGO-aligned, career-professional actors who attach themselves to commons projects and redirect energy toward grant cycles, brand positioning, and compliance governance. They don’t build the soil. They feed on it. And they usually don’t know they’re doing it.
The most common parasite logic is digital scarcity: “everyone should pay their way.” It sounds responsible. It sounds sustainable. It’s also a direct import from market ideology. Digital infrastructure is non-rivalrous – it can be shared at near-zero marginal cost. But scarcity gets reintroduced through subscriptions, premium tiers, paywalled features, SaaS dependency, and professional gatekeeping. That’s enclosure wearing a cardigan. It’s not building commons, it’s rebuilding #dotcons platforms with nicer vibes.
The #NGO layer brings its own infection: risk aversion softened by consensus theatre. Measurable outputs. Depoliticised language. Branding as reputational management. None of it is directly evil, but it’s structurally parasitic – because the moment legitimacy becomes more important than usefulness, you start designing for funders instead of participants. You optimise optics instead of flows, you protect the brand instead of the commons.
This keeps happening because commons produce surplus – trust, energy, attention, infrastructure – and institutional actors are trained to capture surplus. They don’t see themselves as parasites. They see themselves as stabilisers. But when their survival depends on controlling narratives, they can’t help bending the project toward those needs. That’s structural parasitism, not personal villainy.
So ask yourself honestly are you building soil or feeding off soil someone else built? Are you increasing abundance or reintroducing scarcity through “sustainable” monetisation? Are you materially decentralising power or just professionalising it? Commons infrastructure should reduce dependence on gatekeepers, not multiply them.
This is a traditional political view of these people
Pick Up the Shovel
Yes, there are parasites. Yes, there’s shit to shovel. No, pretending everything is collaborative harmony doesn’t help anyone. The work of #OMN and #4opens isn’t trend-chasing or #NGO alignment. It’s building resilient soil, designing against digital scarcity, and keeping governance open and genuinely messy. If that makes institutional actors uncomfortable – good. Composting always smells bad before it becomes fertile.
One last thing: stop burning out alone. The number of good people burning out right now is not accidental. It’s what happens when systemic problems get reframed as personal responsibility. Collective infrastructure is weak, crisis is constant, and nobody can carry that alone. Nobody should try. The solution isn’t heroic individual effort. It’s shared architecture. In #FOSS terms: if the system keeps crashing, stop blaming the users and redesign the stack.
Meany people see the world degrading, enclosure accelerating. They see climate, politics, media all bending toward extraction. And even when they can see the trajectory, they feel powerless, so they cope by optimise their careers. They scroll. They argue. They consume. They retreat into irony. From birth, we’re trained into one core assumption: There Is No Alternative (#TINA).
Not because it’s true, but because every dominant institution reinforces it:
Schools train compliance.
Media normalises enclosure.
Platforms reward performance over substance.
Workplaces absorb our creative energy into extractive systems.
The message is subtle but constant:
“You can’t change anything.”
“Radicals just break things.”
“Be reasonable. Fit in.”
For builders, this message hits differently, because we know alternatives are possible, we’ve already built them. This is the #FOSS Paradox, as free and open source software proves collaboration without enclosure works, commons-based production works, open standards work and distributed governance can work. Yet somehow, the infrastructure we helped build keeps being enclosed.
The #openweb became the #dotcons, protocols became platforms and communities became markets. Not because we failed technically, but because we underestimated scale, incentives, and capture. And too often, we built tools without building parallel social power. The real trap isn’t rebellion – It’s drift – The #mainstreaming system doesn’t survive by crushing everyone loudly. It survives by absorbing alternatives, funding safe versions of dissent, steering energy into manageable channels and exhausting people with maintenance and precarity
Gatekeeping doesn’t always look like repression, more it looks like grants, partnerships, “best practices,” and institutional legitimacy. The result is that talented builders end up reinforcing the systems they once set out to replace. Not out of malice more from survival.
This Is where #OMN and #4opens come In, it isn’t only ranting about what’s broken, it’s about rebuilding missing layers:
Trust
Shared infrastructure
Media flows outside algorithmic capture
Governance rooted in actual participants
The #4opens are not branding, they are structural safeguards:
Open data
Open source
Open standards
Open process
Without all four, enclosure can creep back in, slowly, politely and inevitably.
This Is not about individual heroics, the myth of the lone hacker is part of the problem. What we need for the new “common sense” is that #stupidindividualism is a dead end. Few people escape extractive systems alone, no one builds durable alternatives alone. Collective infrastructure helps build counterweight to centralised power.
That’s what the #Fediverse gestures toward, what the #openweb once promised, and what needs strengthening now. A first step is to stop pretending we’re powerless. If you’re in #FOSS, you already have:
skills
networks
literacy in decentralised systems
experience with commons governance
What’s missing isn’t capability, it’s coordination and shared direction. The first step isn’t dramatic, it’s simple, reject the #NGO path to:
Do something – anything – that strengthens commons infrastructure instead of platform enclosure. The biggest lie Is that there’s no choice, when we keep repeating “this is just how things are,” eventually it becomes self-fulfilling. But history says otherwise, every dominant system looks permanent, until it isn’t.
The real outsiders aren’t the loudest rebels, they’re the ones who quietly stop reinforcing broken systems and start building viable alternatives. That’s what this moment asks of the #FOSS community is not #blocking outrage, not purity and not only collapse fantasies.
So, please stop waiting for permission, build systems that align with human autonomy and biophysical reality by strengthening commons before they’re erased. Because alternatives don’t appear, they’re built, and if we don’t build them, enclosure wins by default.
Pile technology is an interesting and under-discussed organisational pattern that already shapes how many people actually work, especially in #FOSS and grassroots tech cultures.
Instead of hierarchical structures, formal taxonomies, and rigid workflows, pile-based organisation emerges from accumulation: a directory full of files, browser tabs waiting for attention, TODO lists that grow organically, issue trackers used as thinking spaces rather than strict pipelines, mailing lists and chat logs functioning as living archives
This “pile-first” approach is not laziness or lack of structure – it is adaptive cognition. Humans often work by gathering, clustering, and revisiting material over time rather than pre-defining perfect categorisation systems. Many of the most productive hackers and organisers operate this way by collect first, make meaning later with structures emerging from usage rather than planning.
Why this matters for #FOSS paths – A lot of modern tooling tries to impose rigid models with strict schemas, enforced workflows, heavy governance structures and “one correct way” UX patterns. These approaches frequently fail in grassroots environments because they assume clarity exists at the start. In reality, most innovation emerges from ambiguity, experimentation, and partial understanding.
Pile technology supports exploration without premature optimisation with low barriers to participation and iterative sense-making through organic collaboration. This aligns with successful #FOSS practices of rough consensus and running code, scratchpads and prototype repos, forks as exploratory piles, tagging emerging after content exists. In other words: piles are often the pre-structure phase of successful systems.
The shift from paper piles to digital piles? Historically, piles existed physically: cardboard boxes, stacks of notes, folders on desks, clipping archives and activist pamphlet collections. As work moves digital, the nature of piles changes with infinite accumulation becomes possible, where search can be used to replace physical memory. The risk is that digital tools force artificial structure too early, and replace human piles with opaque algorithmic sorting. Neither reflects how real communities think.
Lessons for effective organising, when we take pile technology seriously, we design systems that: allow messy accumulation without penalty, support multiple overlapping ways to revisit material, make recontextualisation easy (tagging after creation) to preserve chronological flow alongside thematic grouping. This maps directly onto many #openweb values of feeds as flowing piles, links as connective tissue and public commons growing through incremental contributions. Instead of trying to eliminate mess, we build tools that metabolise mess into meaning.
For projects like #OMN, about aiming to rebuild grassroots media and collaborative publishing by start with piles, not categories. Let trust and editorial structure emerge from participation. Treat tagging, curation, and narrative as second-order layers on top of accumulation. Avoid premature schema design that excludes contributors. In practical terms this means newswire-style flows are piles, tag streams are reorganised piles and editorial features are curated piles. This path reframes “messiness” from a problem into a core design feature.
Why this matters right now? Many contemporary platforms bot #dotcons and #FOSS optimise for control, engagement metrics, and monetisation rather than human cognition. They flatten piles into feeds designed by algorithms, removing agency from users and communities. A strong “native” #FOSS path can instead embrace human-scale chaos to feed collective sense-making and preserve autonomy over organisation. Pile technology is not anti-structure – it is pre-structure. Understanding this helps us build tools that grow organically instead of imposing brittle frameworks that collapse under real-world use.
We are feeling a cultural current many of us recognise but rarely name clearly. A feeling that something fundamental has gone wrong, not just politically or economically, but culturally. An experience that imagination has narrowed, participation has thinned, and people are increasingly pushed into the role of spectators rather than participants in shaping the world.
This didn’t appear overnight. It grew out of decades of #neoliberal restructuring that reshaped culture, technology, and social life. Collective institutions were hollowed out, public spaces became marketplaces, creativity became branding and community became “audience”. Instead of shared projects, we were offered platforms, instead of commons, we were given services, instead of any participation, metrics.
This cultural shift produced a generation who feel the weight of a system that seems unavoidable – a reality that presents itself as permanent even as it fails to meet human needs. People sense the limits, but struggle to imagine alternatives because the cultural language for collective agency has been systematically eroded.
This is the environment the #dotcons thrive in, where the #closedweb turns culture into extraction and participation becomes only more engagement metrics. Community, user base, conversation content streams are where cooperation is #blocked due to competition for visibility.
And over time, this reshapes what people think about organising itself. Grassroots action begins to look unrealistic, messy, and inefficient compared to polished controlled platform experiences. Then trust disappears, replaced by algorithmic mediation and institutional management.
Yet beneath this dominant culture, another current has always existed, the #openweb culture, rooted in collaboration, experimentation, shared stewardship, and imperfect but real participation. IP protocol stack built on mailing lists, wikis, federated systems, grassroots media, DIY infrastructures, spaces where people build together rather than consume.
This culture never fully disappeared, as it was needed by the mainstreaming, it was just pushed to the margins. The #OMN project grows from this undercurrent, not as a reaction against technology, as a continuation of the parts of internet culture that treated technology as commons rather than a commodity. It #KISS recognises that infrastructure shapes social behaviour, and that rebuilding a healthier culture requires rebuilding the spaces where people meet, publish, and organise.
The difference is social logic, from social platform ownership grows to shared protocols, from central moderation to community mediation, from passive users to active participants. It’s the change from scale-as-growth to scale-as-federation.
Importantly, this isn’t nostalgia or any path to purity politics. The culture that produces #OMN understands that systems are messy. Grassroots projects fail, fork, and struggle. But instead of seeing this as weakness, it treats messiness as the natural process of collective growth. Composting rather than perfection.
The mistake of both corporate platforms and #NGO approaches is trying to engineer clean solutions to fundamentally social problems. The #geekproblem looks for perfect systems; the grassroots path builds resilient ones through ongoing practice.
This is why affinity groups, federated networks, and the #4opens matter. They create structures where trust emerges from shared action rather than imposed authority. The culture behind #OMN is not defined by ideology alone, it is defined by lived practice of people who build together and communities that govern themselves, to remain open to change
In a world that tells us “there is no alternative,” the simple act of building functioning alternatives becomes quietly radical. And when enough small, federated efforts connect, what once felt impossible begins to look normal again. That is how cultural change happens, not through grand declarations, but through many small working examples growing from shared soil.
For sceptical #FOSS engineers, this isn’t an argument for abandoning structure, security, or technical rigour, it’s the opposite. The lesson from decades of open-source development is that trust does not mean naïveté; it means building systems where failure modes are expected and mitigated through transparency, modularity, and federation. #OMN applies these same engineering principles socially: small loosely-coupled groups instead of monoliths, open protocols instead of platform lock-in, observable processes instead of hidden governance.
If “pure trust” sounds unrealistic, think instead of reproducible builds, version control, and peer review, trust emerges from verifiable processes and shared ownership. The goal isn’t utopian social engineering; it’s creating resilient sociotechnical systems where collaboration scales horizontally because no single node becomes a point of failure or control.
