Tag: FOSS

Disciplined curiosity beats IQ, Oxford

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.

For some reflections from the last couple of years around Oxford life and technology culture, see: https://hamishcampbell.com/tag/oxford/

#Oxford #academic #elitist

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.

#KISS

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.

#OMN #OpenWeb #TechPower #Oligarchy #Future #Compost

The #dotcons assume you want to be a techbro

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 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.

Make some FOSS compost

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?

Make some compost.

Why good faith is a technical requirement for #FOSS

Public Money, Private Hype: From Blockchain to AI – and the #FOSS Path Less Taken

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 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:

  1. Default to – Public funding #KISS should require open licenses, open standards, and transparent governance.
  2. Fund Maintenance – Not just #fashionista projects, but long-term stewardship of critical open infrastructure.
  3. Measure Social Value – Not hype, not valuation, not patents, but actual public use and resilience.
  4. Grassroots tech as seedlings – to be open to real change and challenge in tech.
  5. 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.

Why good faith is a technical requirement for #FOSS

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 is a practical test, not a vibe. The 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 .

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.

#indymediaback #openweb #compostingthemess #KISS #makeinghistory #OMN

State Funding of #FOSS and Open Source: Is it a Good Idea or a Bad Idea?

#FOSS needs to take a social lead

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.

Commons and the metaphor of “grow a backbone”

A Minimal, Governable Infrastructure for Trust-Based Media Flows

Human Tech: The Open Media Network (#OMN) is a proposal for human-scale, federated media infrastructure built on standard #FOSS practices and the : 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 :

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 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.

Design Principles Relevant to #NLnet Priorities

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 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

Who’s Building the #Openweb – and Who’s Just Feeding Off It

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 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.

That’s the composting we actually need to do.

The Meta-Mess of the “Open” Social Web

Most people sense that something is off

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 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 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:

  • Find your people.
  • Support projects aligned with the .
  • Build flows, not just features.
  • Connect tools to real communities.
  • Refuse quite capture.

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.

#KISS #openweb #nothingnew #geekproblem

Scale changes everything

Pile technology

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.

An affinity group is not just “a group of people who agree”

The #openweb is the soil, #OMN the seeds

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 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.

The #openweb is that soil, #OMN is the seeds.

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.

#KISS

An affinity group is not just “a group of people who agree”

An affinity group is not just “a group of people who agree”

A practical bridge-building approach for the #openweb / #OMN – for grassroots organisers, Fediverse communities, and sceptical #FOSS engineers.

An affinity group is not simply “a group of people who agree.” It is a functional social tool: small enough to build trust, structured enough to act, and open enough to grow.

A working path is to start with purpose, not only ideology. The biggest mistake is forming around identity or theory rather than function. Affinity groups work when they are built around shared work, not shared labels. So for #OMN, instead of saying “let’s build an affinity group for radical media,” we try something concrete like: “a small group committed to building and testing OMN publishing workflows for real users.” A clear, practical purpose lowers defensive reactions and creates common ground.

Ideal size and composition matter. Affinity groups historically work best with around 4–8 people – large enough for diversity, small enough for trust. This avoids both NGO-style bureaucracy and lone-founder burnout. Useful roles include: builder (technical), organiser (social process), storyteller or documenter, critic/tester (essential for reducing groupthink), and connector (linking to the wider network). These are roles, not hierarchy.

Trust must be built through practice. Many people distrust grassroots projects because they have seen “pure trust” models fail. So don’t rely only on ideological alignment, build procedural trust instead. Examples include small, regular deliverables (“what did we actually ship?”), rotating facilitation, transparent public logs where possible, and shared infrastructure ownership, so no single person holds control. Trust grows from repeated, visible action.

Clear boundary rules prevent both NGO capture and chaos. Without boundaries, affinity groups dissolve. Keep rules simple and aligned with #KISS: anyone can observe, participation requires contribution, decisions are made by consent or rough consensus, and there are no permanent leaders, focus more on rotating roles. Forking is allowed, following federation principles. This mirrors ActivityPub socially as well as technically.

Mediation is built into #OMN. Use soft mediation practices such as assuming good faith but verifying through actions, and asking whether behaviour supports the shared task. When conflicts cannot be resolved, allow parallel experiments rather than endless arguments. This avoids the classic problem of well-meaning people unintentionally derailing collective work.

Avoid the #NGO trap from the start. Instead of mission statements, boards, and strategic documents, focus on working notes, small experiments, and iterative prototypes. Document reality rather than intentions. NGO structures often push power upward; affinity groups keep power at the edges.

Bridge-building with #FOSS and Fediverse communities is essential for adoption. Frame #OMN affinity groups as neither anti-engineering nor anti-structure, but anti-centralised control. Messaging like “we’re applying federation principles socially, not just technically” resonates strongly with #ActivityPub builders and open-source contributors.

Growth should happen through replication, not scaling. The affinity group is not the movement – it is a seed node. New participants do not simply accumulate; instead, new affinity groups form. Groups coordinate through federation via shared protocols and culture. This approach mirrors #Indymedia nodes, the early Fediverse, and many successful activist networks.

Concrete first steps: identify 3–5 people already doing related work; define one narrow OMN goal; hold a weekly 60–90-minute working session with a public log; rotate facilitation from the beginning; and ship something small within two weeks. Momentum builds legitimacy.

Affinity groups solve three problems simultaneously: they prevent NGO-style centralisation, reduce lone-founder burnout through shared responsibility, and resist #dotcons growth-for-growth’s-sake logic. In many ways, they are the social equivalent of federation.