We need to have a clearer, more grounded conversation about “security” and what it actually means in the context of the #openweb. There is a long history of thinking in #FOSS spaces that security is something we can solve purely technically: better encryption, better protocols, better architectures. But in everyday life and practice, people need to work from a much simpler starting point – We do not trust client–server security. We only meaningfully trust what can be verified through the #4opens. And even with #p2p, we keep our trust closed limited.
Why? Because the underlying systems people actually use are insecure by design: old phones, opaque operating systems, proprietary blobs built and controlled by #dotcons. You can build the most secure system in the world, but if the people you are communicating with are using compromised devices, then your security collapses to their level.
That’s the bit people who fixate on closed don’t like to face. So a #KISS approach helps cut through the illusion – At normal use, there is very little real security. At paranoid levels, security breaks down socially, because you still need to interact with people operating at the normal level. That doesn’t mean security doesn’t matter. It means we need to stop pretending it technically works in isolation from social reality.
Why closed paths, spaces and projects fail socially, is a harder point. Closed systems are often justified in the name of security, privacy, or control, but socially, they create a very different dynamic in that they remove visibility. And without visibility, you cannot form shared judgment, without shared judgment, you cannot have social truth. In closed environments, bad actors – call them “monsters” if you like – can manipulate, divide, coordinate in the dark to avoid accountability, because there is no wider context to test what is happening.
In open systems, the same actors exist, but they are much easier to see, challenge, and trip up, because conversations are visible, processes are transparent and history is accessible. Closed breeds monsters, open pushes them out of the light and into the shadows. This is why, for the #openweb, “closed” should be deliberately limited and clearly bounded, not expanded as a default.
There is a very real social problem on this with #Encryptionism, as a social project as it is where meany parts of the #FOSS world go wrong. There is a strong tendency – what we call the #encryptionists – to treat encryption as a kind of universal solution, were in reality, this to often becomes: a focus on abstract technical purity, a dismissal of messy social reality to retreat into systems that don’t scale socially. And too often, aligns – ironically – with the same #deathcult logic it claims to resist: control, fear, and abstraction over lived practice. Encryption is a tool, not a culture.
This brings up the #Geekproblem – put simply – The people building the tools often cannot see the social problems those tools create. Even when those problems are pointed out repeatedly, over years, with real-world examples, the response is often negative and #blocking – to retreat into technical framing, to rephrase the issue in jargon, to build another “better” tool that misses the point.
A useful way to explain this to the #FOSS crew is yes, jargon can be messy, but this is not just about language. The deeper issue is cultural blindness, lets look at a concrete example that might help in bridging: #Indymedia was a ten-year working global experiment in open publishing and #4opens practice. And, yes, it ran into exactly these tensions, in the UK, the project fractured along three lines:
#Encryptionists – blocking aggregation due to abstract security concerns
#Fashernistas – pushing shiny but incompatible “better” solutions
#Openweb practitioners – arguing for simple, interoperable approaches (like #RSS)
Instead of adopting existing standards like RSS, parts of the project built new, incompatible formats, “better” on paper, but useless in practice. The result? Fragmentation, internal conflict, loss of interoperability, eventual collapse. All three sides lost. This pattern should feel familiar, you can still see it today in parts of the Fediverse.
The practical path forward, starts with taking this history seriously, then a few things become clear, that closed should be minimal and purposeful, not the default. Open processes (#4opens) are the only scalable form of trust, interoperability beats cleverness, social reality matters more than technical purity. And most importantly we need to design for the world as it is, not the world we only wish existed.
One Foot In, One Foot Out. Right now, most people are still inside the #dotcons. So the path forward isn’t purity, it’s transition. The approach we are taking with #OMN, it is simple, install and configure usable #openweb tools, make them accessible, let people use them alongside existing platforms to support a gradual #walkaway culture. One foot in. One foot out. If enough people take that step, the balance shifts.
But to take this step we need to compost the closed, we don’t need to destroy everything that exists, we need to compost it. Take what works, turn over what doesn’t, to grow something better from the remains. That means being honest about the limits of security, about the dangers of closed systems and about the cultural blind spots in #FOSS. If we can do that, we have a chance to build an #openweb that actually works.
If we can’t, we will keep repeating the same failures – just with better code.
Hamish Campbell is a long-time #openweb activist and technologist working on grassroots media and digital commons. He was involved in the early development of #Indymedia and continues this work through projects like the Open Media Network (#OMN), which works on how federated tools and community publishing supports public-interest media infrastructure. His focus is balancing building native platforms and on growing the social culture that makes the #openweb work: transparency, decentralisation, and horizontal collaboration. Through writing, workshops, and practical projects, he argues that the future of the Fediverse depends as much on culture, governance, and shared infrastructure as it does on code.
Purpose is to open conversation that many people feel but rarely articulate: the tension between grassroots culture and institutional capture. Start with your simple distinction:
Bad #mainstreaming → corporate/NGO structures reshaping the Fediverse
Then ask: “Which direction are we currently moving?”
Discussion topics – funding and governance, foundations and institutional capture, developer vs user power, infrastructure vs platforms. How to avoid repeating Web 2.0
Activity is to ask participants to map layers: Grassroots – NGO / institutional – Corporate. To discuss where power currently sits and what healthy balance might look like.
Outcome is people leave with language to understand the tensions they are experiencing in the Fediverse.
Workshop 02
Maybe a second one on why #makeinghistory is needed? Translating #OMN from “activist infrastructure” into “missing public digital infrastructure.” That language is what this event is trying to figure out. The Open Media Network (#OMN) proposes a model where grassroots publishing, community moderation, and institutional participation are balanced. Participants can discuss how institutions support shared infrastructure rather than just deploying isolated platforms.
Many institutions are experimenting with the Fediverse as an alternative to #dotcons corporate social media. However, simply running institutional servers risks reproducing the same platform dynamics in a federated form. We need workshops that explore the broader ecosystem of public-interest media infrastructure.
“What happens after institutions join the Fediverse?” The #KISS answer is they need to support the commons infrastructure that makes it socially viable. Running Mastodon is not enough, institutions need to support the wider open media ecosystem.
Talking about #openweb culture in a constructive way is tricky because most #FOSS and Fediverse conversations default to technical framing: code quality, scalability, moderation tooling, and #UX. These things matter, but they are not the foundation that determines whether a network lives or dies.
Maybe a useful way to open the conversation is to shift the starting point. Instead of saying “culture is important too”, say something stronger but practical: The success or failure of open systems is primarily a cultural question, not a technical one. The code only expresses the culture behind it.
Start with a simple historical observation. Many technically strong systems failed because the social layer was weak, while some technically rough systems succeeded because the community culture worked.
Examples from the open web – early open source projects that thrived because communities shared norms of collaboration. Grassroots networks like Indymedia worked socially even when the software was messy. Corporate platforms that succeeded not because they were technically better, but because they built powerful social gravity.
The pattern is clear, that technology enables networks, but culture sustains them. This is the missing step in most Fediverse conversations. Right now to meany discussions focus on: scaling servers, moderation tools, interface design and onboarding. These are all necessary but insufficient.
What way to often goes missing is the deeper questions – What culture are we actually trying to grow? Without answering that, the system tends to drift toward the dominant internet culture, which today is shaped by the #dotcon platform model of engagement optimisation, algorithmic attention markets, influencer dynamics and centralised power. When that culture seeps into the Fediverse, the result is a federated copy of the same problems.
So why is culture harder than code? Code can be written by a few developers, culture requires shared understanding across thousands of people. To grow this we need native governance norms, trust networks, moderation values and expectations about ownership and participation to hold to native paths for how conflict is handled. These things cannot simply be implemented in software, they must be grown socially, fail to address this is why many technically strong projects fail, they assume the social layer will somehow emerge automatically. It rarely does.
To make this constructive, it helps to clearly describe what we mean by #openweb culture. Some core values historically included public-first communication rather than platform ownership, decentralised responsibility instead of central moderation authority, commons thinking rather than product thinking to nurture horizontal participation rather than audience/influencer hierarchies, this need clear #4opens processes rather than opaque decision-making.
These values were never perfect, but they created a different social environment from today’s corporate social media. If we do not actively cultivate these values, the surrounding internet culture will slowly overwrite them. If the Fediverse continues to grow without addressing culture as it currently is, the most likely outcome is large institutional instances dominate, smaller community spaces struggle leading to more moderation being centralised. This all shifts user expectations toward platform-style experiences.
At that point, the system may still be technically federated, but the culture will have drifted back toward Web 2.0. The code will be open, but the social dynamics will not be.
So the “extra step” is simply, we must talk about culture as deliberately as we talk about software architecture. That means asking questions like: What social norms should Fediverse communities encourage? What governance models support open participation? How do we keep the ecosystem diverse rather than dominated by large actors? What responsibilities come with running infrastructure in a commons network?
These conversations are sometimes uncomfortable, because they move beyond engineering into politics, sociology, and ethics. But avoiding them does not make them disappear, it simply means the culture will be shaped by default forces instead of conscious choices.
A simple way to frame this – A phrase that often works well in discussion is – “Code builds the network, but culture decides what the network becomes.” If we want the #openweb to remain something different from the #closedweb platform internet, we need to invest as much thought into the culture as we do into the code and #UX. Otherwise, the technology may succeed technically, but the social project behind it will quietly fail.
Public Money, Public Communication, Public Infrastructure
Public institutions are funded by taxpayers. Their role is to serve the public. So it should be obvious that their communication systems are open, accessible, and accountable to everyone -without requiring people to sign up to proprietary, for-profit platforms.
Yet this is not the world we live in. Today, much of public communication is effectively outsourced to the #dotcons. If you want to follow government updates, participate in consultations, or even access timely public information, you are often expected to create an account on a closed platform – designed for profit, data extraction, and behavioural manipulation. That alone should raise serious questions.
This contradiction is especially stark in Europe as they regularly speak about digital sovereignty, data protection and public accountability. And yet, at the same time, they rely on U.S.-based corporate platforms to communicate with their own citizens. It’s a strange situation:
Public institutions, funded by European taxpayers, using foreign, proprietary infrastructure to mediate public communication.
Not only does this create dependency, it also places public discourse inside systems that are not governed by public interest.
It’s not just ironic. It’s structurally broken, we should think about prosicuting the people who have made this happen.
The access problem, useing closed platforms to access public communication creates real barriers: Not everyone wants to create or maintain dotcons social media accounts. Some people are excluded for ethical, political, or practical reasons. Algorithms decide what is seen and what is not. Public information becomes entangled with advertising and engagement metrics. This undermines a basic democratic principle that public communication should be universally accessible, without conditions.
We already have an alternative to this curupt mess, the #DIY#OpenWeb comes from europe, it offers a different path. Instead of #closedweb platform dependency, it builds on open standards, interoperable systems with multiple access points, no user lock-in. This is not a new path, it is how the web was originally created to work in the EU.
An example project that contines this native mission and supports this is the #OMN whitch creates spaces where public institutions and public communities can meet on equal terms, without one dominating the other, and without relying on closed corporate systems. If institutions instead invest in and support the wider #OMN ecosystem, they help build something fundamentally different, a public communication infrastructure that is open by default, accessible to all, resilient and distributed and aligned with democratic values.
A simple principle, if it is funded by the public, it should be accessible to the public – without restriction. No accounts required, no platform dependency and no hidden gatekeepers.
We need to organise a call to act. Public institutions need to move beyond simply using the #Fediverse. They need to help build and sustain the commons that makes open communication possible. That means, supporting open infrastructure projects, funding shared ecosystems like the #OMN and building real, not facke PR commitment to public-first communication practices.
This is not just a technical shift, it is a political and cultural choice.
A simple #KISS way forward is to shift public social communication onto the #Fediverse. This is already a significant improvement on current platform dependency. However, I want to raise a point that may sound controversial at first, but is actually quite practical: public institutions should not rely exclusively on the existing codebases.
Most current Fediverse platforms have done vital groundwork – particularly in establishing shared protocols, interoperability, and a working culture of federation. That contribution is important and should be recognised. However, many of these tools evolved shaped by the same assumptions as #dotcons and constrained by #NGO project models. As a result, they can be complex, difficult to maintain, and not always well aligned with the long-term needs of public institutions or commons-based infrastructure.
A constructive path forward would be to fund the development of a small number of new, purpose-built codebases focused on commons publishing. Not one, but three parallel implementations.
Why three? Because diversity reduces risk. In practice, not every project will succeed – this is normal and expected. Funding multiple approaches ensures resilience, encourages innovation, and avoids over-reliance on a single solution. The cost of doing this would be minimal relative to existing public digital budgets, yet the potential long-term value is significant.
Importantly, this is not about replacing the existing ecosystem. Because the Fediverse is built on shared protocols, any new tools would remain fully interoperable with current platforms. This means users of existing services can still interact seamlessly, while the overall ecosystem becomes stronger, more diverse, and better aligned with public service values.
In short: build on what exists, but don’t be constrained by it. By investing modestly in new, commons-oriented infrastructure alongside the current tools, public institutions can shape a more robust, sustainable, and genuinely public digital communication space.
Outreach to @newsmast interesting to see the #NGO view of the real alt path we need to take https://hamishcampbell.com/thinking-of-workshops-to-run-at-nodes-on-a-web-noaw-unconference/ you guys might be interested in working on the 3ed workshop outline. The 3 codebase need to be 1) mainstreaming, 2) radical #NGO and 3) native messy grassroots. You guys could be the second codebase. We do need diversity, best not to keep blindly messing up this path in the current globe mess.
Stopped going to in-person general tech conferences around 15 years ago – they’d become beyond pointless. Since then, I’ve stuck to more focused online events.
Now heading back to an in-person one. Curious what I’ll actually find.
I have a feeling it’ll be about 75% pointless, 20% narrow geek, academic and #NGO-focused (slightly useful), and maybe 5% – probably less – actually useful.
There is a point that often gets misunderstood in conversations about the future of the #openweb and #FOSS that #mainstreaming itself is not inherently good or bad. What matters is who is influencing whom. We can think of it in two very different directions.
Good #mainstreaming is when the values of the #openweb move outward into the wider world: Transparency, decentralization, cooperation, shared infrastructure and community governance. In this case, mainstream society learns from the cultures that grew around free software and open networks. But there is another direction.
Bad #mainstreaming happens when the mainstream flows inward and reshapes the open ecosystem in its own image. The values that arrive tend to look like this: corporate control, surveillance capitalism, hierarchical governance, branding over substance leading to growth and extraction over community. In this case, the #openweb is not influencing the mainstream, the mainstream is absorbing and reshaping the openweb. And historically, that absorption rarely ends well.
This second bad option of co-option Is the default, in the current context, mainstreaming tends to dilute radical alternatives into market-friendly compromises. This is not accidental, the system many of us are working inside – what I often call the #deathcult of neoliberalism – does not absorb things in good faith, it absorbs them in order to neutralize them.
We have seen this pattern repeatedly when open communities become venture-backed platforms, cooperative tools become monetized services, grassroots networks become brands. What begins as a commons to often ends as a product. For people building or funding #FOSS infrastructure, this pattern should be familiar.
Because of this messy dynamic, we need active mediation when interacting with mainstream institutions. Not blanket rejection, but not naïve acceptance either. The question is always contextual: Is the mainstream being influenced by open values or are open communities being reshaped to fit mainstream power structures? Right now, the balance is heavily tilted toward the latter, which means the priority is not endless integration. The priority is protecting and strengthening the roots of the #openweb.
Thinking about this kinda mess making helps to highlight the problem of the #NGO Path, where the NGO layer becomes problematic. The people involved are sometimes well-meaning, many think they are genuinely trying to help. But the institutional incentives they operate under reshape projects in subtle but powerful ways.
Our #FOSS funding structures push toward professionalization, opaque centralized governance, brand management, risk avoidance that is compatibility with existing power structures. Over time, this acts like a kind of social poison inside grassroots ecosystems. That might sound harsh, but it is simply a reality of social dynamics and institutional gravity. People working within those systems carry those assumptions with them, often without realizing it.
For the health of the ecosystem, we need to mediate our intake of that poison. This is not about demonizing individuals, it is about recognizing structural effects. There is no contradiction in saying both things at once: They may be good people – Their institutional logic still damages grassroots culture. So a useful rule of thumb is simple is don’t drink too deeply from the #mainstreaming.
Visibility Matters – Another issue for #FOSS projects is much more practical – Grassroots infrastructure often stays invisible. If people don’t know a project exists, they cannot adopt it. And when that happens, the public will naturally drift toward the next “ethical” platform marketed by the very companies reproducing the #dotcons model. The difference is that those companies have huge PR budgets. If open projects do not communicate what they are building and why it matters, the narrative will be written elsewhere and it will not favour the commons.
The real value of the #OpenWeb at its simplest, the #openweb path does something very straightforward in that it empowers horizontal, DIY culture and dis-empowers vertical, closed systems. That shift alone has enormous value.
It changes who gets to publish.
It changes who controls infrastructure.
It changes who participates in shaping the network.
Yet one of the strangest things in the current moment is how many people actively reject or ignore this possibility. Part of that blindness comes from habit, part from career incentives, part from the cultural gravity of the mainstream. But the result is the same: the tools that could strengthen public digital space are sidelined in favour of systems designed primarily for profit.
So what can maintainers and funders do? If you maintain or fund #FOSS infrastructure, there are a few practical steps that can help strengthen the ecosystem:
Fund the commons, not just products. Support infrastructure that serves communities, even if it does not generate revenue.
Protect open governance. Funding models should strengthen community decision-making rather than centralizing power.
Support grassroots visibility. Help projects communicate what they are building and why it matters.
Resist quite capture. Watch for subtle shifts where open projects become shaped by market logic or branding priorities.
Invest in horizontal ecosystems. The long-term health of the web depends on many small interconnected projects, not a few dominant platforms.
The choice in front of us is the future of the #openweb will not be decided by technology alone. It will be decided by culture, governance, and resource flows. If the current trend continues, open infrastructure will increasingly be absorbed into corporate platforms, #NGO programs, and venture ecosystems.
But there is another path, slower one, messier, more grassroots one. One that keeps the web as a commons rather than a marketplace. Whether that path survives depends heavily on the choices made by #FOSS maintainers and the people who fund the work.
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, governance models, and whether something actually runs. Good. That discipline is why free software exists at all.
But here’s the 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 survival architecture. Composting the current rot is why #OMN exists as a project. We are living in a digital environment thick with enclosure and manipulation. 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. #OMN is a shovel, not a cathedral. It’s 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 purity, it’s about durability. We can keep polishing tools for the tiny minority who enjoy living inside the #geekproblem, but, we 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.
Built on #4opens and Standard FOSS Process
The OMN stack adheres to:
Open data
Open source
Open process
Open standards
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.
What Funding Enables
Support from funders such as NLnet would allow:
Formal specification of the #5F architecture
Reference FOSS implementation
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
Why use strong words, because there are parasites and shit to shovel. Why this is helpful? Because it gives the people who are currently being default parasitic a chance not to be, and the people who are creating #techshit space to compost some of this mess making. If they do, fantastic, a kindness has been done. If they don’t, we can compost the #fuckwits ourselves to grow something better #KISS.
“Impossible” is a horizon, not a boundary, not a fantasy, it is a pattern in history – slavery abolition was “impossible.”, Universal suffrage was “impossible.”, Worker self-organisation was “impossible.” An open, global communication network outside state control was “impossible.” Until people acted as if it weren’t. The function of calling something impossible is too often, political, about narrowing imagination and disciplining ambition, to keep demands within the limits of what current power structures find tolerable.
But structural shifts rarely start as “reasonable proposals.” they start as overreach – commons infrastructure, resisting enclosure, pushing back on identity-gated speech, building beyond scarcity logic – If we only aim for what seems immediately feasible within existing incentives, we tend to only reinforce those incentives. If we aim beyond them, we can change the terrain, we may not reach the “impossible” goal, but we shift what becomes possible next. That’s the wager, it’s not utopian perfection or strategic overreach, historically, it’s acturly #KISS how the boundaries move.
With this firmly in mind, it’s useful to talk in metaphors, the poetry of life balances communication with blunt truth. Let’s look at current mess making. Open spaces attract life, they also attract parasites, that’s ecology. The #openweb and #4opens spaces generate value:
code
trust
collaboration
legitimacy
cultural capital
By non of this is stable, composting Is real work, when drift sets in, someone has to shovel. It’s messy, exhausting, unpaid and constant, because digital commons produce nutrients – and institutional actors are trained to harvest nutrients. If nobody composts the shit, the projects choke. Where value accumulates, extraction follows, the “parasite class” in tech isn’t evil masterminds. They tend to come from a layer of actors – often institutional, often NGO-aligned, often career-professional – who attach themselves to commons projects and redirect energy toward grant cycles, branding positioning and compliance governance trends. They don’t build the soil, they feed on it.
One of the Infections that feed this mess is digital scarcity, the most common parasite logic is simple, “Everyone should pay their way.” It sounds responsible, mature, 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 logic is reintroduced through:
subscriptions
premium tiers
paywalled functionality
SaaS dependency
professional gatekeeping
That’s enclosure wearing a cardigan, not building commons, it’s rebuilding platforms with nicer vibes.
The #NGO layer brings its own metabolism of risk aversion, soferned by consensus theatre. This “game” is about measurable outputs, depoliticised language and in the end branding as reputational management. Again, not directly evil, but structurally parasitic to native grassroots paths. Because the moment legitimacy becomes more important than usefulness, the centre of gravity shifts. You start designing for funders instead of participants, optimise optics instead of flows. You’re protecting the brand instead of the commons.
So it’s useful to ask why this keeps happening? Because the commons produce surplus of trust, energy, attention and infrastructure. 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 control by managing narratives, they can’t help bending the project toward those needs. That’s structural parasitism.
The real questions, where the value is, are you building soil or feeding off soil someone else built? Are you increasing abundance or reintroducing scarcity through “sustainable” monetisation? Are you decentralising power materially or professionalising it? Be honest, use the shovel test, are you building out the commons, or are you feeding on commons energy. Commons infrastructure should reduce dependence on gatekeepers, not multiply them.
The spiky bottom line: Yes, there are parasites. Yes, there’s shit to shovel. No, pretending everything is collaborative harmony doesn’t help. The work of the #OMN and #4opens isn’t trend-chasing or NGO alignment, it’s building resilient soil, designing against digital scarcity, protecting flows from enclosure by keeping governance open and messy.
If that makes institutional actors uncomfortable, that’s fine. Composting always smells bad before it becomes fertile. The question is whether we’re willing to pick up the shovel – or whether we’d rather keep pretending the pile isn’t growing.
Some advice, stop burning out alone, the number of good people burning out right now is not accidental. It’s what happens when systemic problems are framed as personal responsibility.
Collective infrastructure is weak and crisis is constant. No one can carry that alone, and no one should try.
The solution isn’t heroic effort, it’s shared architecture. In #FOSS terms: if the system keeps crashing, stop blaming the users, redesign the stack, that’s the composting we actually need to do.
