Permacomputing

From P2P Foundation Wiki
Jump to navigation Jump to search

= "a community of practice oriented around issues of resilience and regenerativity in computer and network technology inspired by Permaculture." [1]

URL = https://permacomputing.net/


Description

Permacomputing:

"There are huge environmental and societal issues in today's computing, and permacomputing specifically wants to challenge them in the same way as permaculture has challenged industrial agriculture. With that said, permacomputing is an anti-capitalist political project. It is driven by several strands of anarchism, decoloniality, intersectional feminism, post-marxism, degrowth, ecologism.

Permacomputing is also a utopian ideal that needs a lot of rethinking, rebuilding and technical design work to put in practice. This is why a lot of material on this wiki is highly technical.

Most importantly, there is no permacomputing kit to buy. See permacomputing as invitation to collectively and radically rethink computational culture. It is not a tech solution searching for a problem. You are free to start your own initiative and use the term permacomputing, however please make sure you understand the purpose and ethos of this project."

(https://permacomputing.net/)


Principles

Permacomputing:

"The principles of permacomputing are:

  1. Hope for the Best, Prepare for the Worst
  2. Care for All Hardware — Especially the Chips
  3. Observe First
  4. Not Doing
  5. Expose the Seams
  6. Consider Carefully the Interaction Between Simplicity, Complexity and Scale
  7. Keep It Flexible
  8. Build on Solid Ground
  9. (Almost) Everything has a place
  10. Integrate Biological and Renewable Resources ."

(https://permacomputing.net/permacomputing/)


Details

Hope for the Best, Prepare for the Worst

"It is good practice to design systems that are resilient and tolerant to interruptions and even if you do not personally believe such scenarios are imminent. This principle invites reflection: why prioritize resilience? Rather than being a defeatist mindset, it is a practical exercise.

By imagining a world shaped by limits, constraints and planetary boundaries, you sharpen your creativity and adaptability. Acknowledging breakages happen and taking into account the possibility of collapse can inspire self-imposed limitations that lead to resourceful solutions—often uncovering societal scenarios previously unexplored, while also acknowledging that less privileged groups are already experiencing harm and damage.


Care for All Hardware — Especially the Chips

Caring for the planet also means caring for the material foundations of digital technology: our hardware. Every device, chip, and component originates from Earth’s finite resources—and eventually end up as e-waste.

The production of new hardware, especially microchips, which are at the heart of nearly every device we use, is highly resource-intensive and energy-consuming. Microchips are particularly problematic because they are difficult to recycle, cost an immense amount of energy and resources to manufacture and their production is highly polluting. Maximizing the lifespan of hardware components is critical for reducing environmental impact and promoting a more sustainable and less harmful digital culture.

One of the core principles of permaculture is to "produce no waste," encouraging us to value and reuse all resources at hand, turning waste into a resource whenever possible.

Digital technology cannot be produced without waste. To mitigate this situation, this principle calls us to step outside the capitalist model of perpetual consumption and growth. Instead, it invites us to recognize the inherent value of the devices, components, and materials we already have—and to care for them intentionally. Caring for the planet also means caring for the material foundations of digital technology: our hardware. Every chip and component is made from Earth’s finite resources, and once discarded, becomes part of the growing e-waste crisis. By acknowledging that these devices are not self-sustaining, we underscore the importance of extending their lifespan through intentional maintenance and thoughtful use.


Observe First

Before taking action, it’s important to first observe. What are the current relations? What is valuable and beautiful? What is needed? What problem are you trying to solve? Is it a social issue? Does it even require technology? If not, refer to Principle "Not Doing". If technology is necessary, what is its purpose, and who will benefit?

In permaculture, before working on a piece of land, it’s essential to observe it over time, ideally through at least one full seasonal cycle. This process helps reveal insights about what can be done with minimal intervention, using limited resources and energy. Similarly, permacomputing involves carefully observing a problem or situation to create space for evaluating what needs to be done and how.

Observing can also relate to sensing the world, where computing can play a key role in strengthening ecosystems through citizen sensing and science projects. Careful observation—gathering data on air quality, water, biodiversity, local temperatures, and more—can help citizens collect the evidence needed to advocate for a healthier environment. These projects gather data on pollution, biodiversity, weather, and more, which can then be used to push for a healthier environment for both humans and non-humans.


Not Doing

To reduce the resource use and waste generated by technology, embracing 'not doing' aka 'refusal' is essential for achieving degrowth. Given computing’s potential for violence and oppression, resistance and collective action must go beyond abstract ideals of justice. They should create opportunities to question the foundations of technical projects and actively reimagine more just futures. By refusing the idea of technological inevitability, we enable forms of resistance to emerge and alternative futures to be considered.

The history of computing is deeply intertwined with capitalism and militarism. From playing a role in warfare and geopolitical power struggles to driving the automation of labor, computing has significantly contributed to the increased use of resources and fossil energy. The latest example of this trend is the construction of hyperscale data centers for running generative AI. Despite the promise of increased efficiency, the Jevons Paradox applies: higher efficiency tends to lead to greater resource use. Efficiency is often presented as a technical solution to a political decisions about how and why we use computing —without questioning the extractive business model.

Curbing demand through refusal has proven to be one of the most effective ways to reduce computing’s harm to people and the planet, and that's where the value of 'not doing' comes in. By observing and questioning what is truly needed, we bring attention to the broader issues: What is necessary? Who benefits? Who is harmed? And what are the impacts on the human and more-than-human environment?


Expose The Seams

Seamlessness in software obfuscates inner-workings and is a myth: things are only seamless to those who fit an idealized standard. To complicate things, software vendors often use the term "transparency" when in fact still designing interfaces in which underlying processes remain hidden to the user. However, making a technology appear transparent or seamless to users, can become an obstacle to understanding how it works, to critical engagement, and to knowledge and skill sharing. Obfuscating inner workings could also be intentional - it makes it harder to question and challenge a technology and, by extension, systematic oppressions.

Exposing some of the inner workings of infrastructure is also essential to making it tangible and to help understand meaning, motivation and materiality: Why has it been implemented this way? How much energy does it use? What processes are happening in the background? Showing the seams is important for decision making about computational processes: are they really needed? How often and how much resources should they be allowed to consume? Who needs access? Who can repair, stop or restart it?

Not everything needs exposing, however. Although this principle doesn't concern personal information, it can be confused with the call for full transparency which is considerably dangerous to some and undesirable for most (forced and full transparency can be dangerous to hactivists and activists alike) .


Consider Carefully The Interaction Between Simplicity, Complexity and Scale

Some simple systems need less energy, less hardware, and less maintenance. They are easier to understand, adapt, and share. By keeping things simple, we create space for care, accessibility, and long-term sustainability. At the same time, especially in relation to programming languages and hardware design, what is perceived as simple can be energy inefficient and arcane. Similarly, from scaling up datacenters to scaling up the resilience of off-the-internet wireless networks and protocols, scale is also an ambivalent notion in telecommunication, network infrastructure and topologies.

There is no magic bullet.

We acknowledge that some problems are inherently complex and achieving simplicity can be the result of a difficult and arduous process. Sometimes simplicity is simply not possible. However, this phase of questioning is rarely properly addressed. The idea of uncritically "enjoying a good challenge", combined with over-engineering and scaling up for the sake of scaling up, prevents assessing if keeping it simple will suffice. Sometimes, a partial, semi- or non-automated, supervised, or otherwise "incomplete" solution is the most appropriate choice for everyone involved.


Keep It Flexible

Flexibility means adaptability to different purposes and circumstances, including ones that were never even considered by the original designer. While we value simplicity, we know that very simple systems can also be inflexible, and this principle exists as a counterweight to that kind of oversimplicity. Ideally, one should aim at a mutually supportive balance between simplicity and flexibility.

Computing systems should adapt to the changes in their operating environments (especially in relation to energy and heat). 24/7 availability of all parts of the system should not be required, and neither should a constant operating performance (e.g. networking speed).

If it is possible to imagine all the possible use cases when designing a system, the design may very well be too simple and/or too inflexible. Smallness, simplicity and flexibility are also part of the "small, sharp tools" ideal of the Unix command line. Here the key to flexibility is the ability to creatively combine small tools that do small, individual things.


Build On Solid Ground

Consider when to build on solid ground and when to design for disappearance. If longetivity is required some considerations are needed.

Many computing systems are based on platforms, frameworks or even languages that change very rapidly, may become obsolete at any time, and are too complex to be easily reimplemented. This principle exists to minimize obsolescence and superfluous maintenance work in systems intended to last.

It is good to experiment with new ideas, concepts and languages, but forming hard dependencies on them is usually a bad idea. Appreciate mature technologies, clear ideas and well-understood theories when building something that is intended to last. Software that uses open, well-documented standards will be more useful in communicating with the wider technological world. It also means that data can survive and still be readable even if the software is no longer functioning.


(Almost) Everything has a place

There is a place for almost everything. Nothing is obsolete or irrelevant. Even if they lose their original meaning and context, most programmable systems may be readapted to new purposes for which they were not originally designed. Think about technology as a rhizome rather than a "highway of progress and constant obsolescence".

Computing is often framed as a kind of ideal universal medium. But the reality is that computing is culture! It can be very diverse, full of color, contingency and expression that is part of any cultural production. Sadly in practice, and in its current form with military industrial roots, this culture exists mostly to reproduce and reinforce existing power structures within societies and support economic growth. Today's computing cultures are still dominated by Human Interface Guidelines designed and controlled by a small group of people with similar backgrounds, priorities and values. But if we can let go of some of the ideas of technological conformity, we might start to see a much wider spectrum of possible ways of computing, some of which might better reflect local needs, desires and societal issues.

This can also open to much wilder and diverse creative practices and aesthetics.


Integrate Biological And Renewable Resources

Permacomputing seeks to support sustainable and regenerative practices, playing a beneficial role in natural ecosystems, but until we can grow computers on trees, this goal remains largely aspirational. The whole electronic industry is based on using some of the most artificial materials ever created. The majority of computer components are firmly tied to complex, extractive and exploitative manufacturing processes linked to the semiconductor industry. There is an increasing incentive and an increasing number of experiments to replace some physical parts of digital hardware with more sustainable materials, while rethinking how supply chains can be more ethical. How can this be encouraged? How can this be prioritized? How can this be more than symbolic or marketing?

In the same sense, we can think of energy use, not just in terms of efficiency but also in terms of local impact. Stemming from the observed principle, see to what extent it is possible to work with (local) biological and renewable materials and resources. Not only does this minimise the ecological footprint of the supply chain, it also allows for a closer relation to nature.

By using more basic kinds of materials, we attend to the labour of making, which pushes us to reflect on conditions, resources, and access to resources as well as how energy is generated, materials decompose and matter is recycled. Crafting, DIY and idiosyncratic approaches to hardware design can help situate computing culture and reveal points of friction."


Directory

off Permaculture-compatible minimalist software [2] :

  1. Seppo - publish short texts and links, and socialise in the Social Web (a.k.a. the Fediverse) - https://seppo.social/
  2. Awesome Small Web Publishing - a curated list of small web publishing tools and frameworks - https://github.com/peterdesmet/awesome-small-web
  3. Cable - lightweight peer-to-peer chat protocol - https://cabal.chat/
  4. Cerca - lean web forum software - https://cerca.io/
  5. Collapse OS - FORTH based OS and tools to preserve the ability to program microcontrollers through civilizational collapse - http://collapseos.org/
  6. Chifir - a system for software preservation - https://chifir.net/
  7. Civboot - a seed from which can grow the essential technology of a civilization - https://civboot.org/
  8. Coalescent Computer - simple and unenclosable social computing platform designed to replace the architecture and use cases of the World Wide Web - https://coalescent.net/
  9. DawnOS - operating system for SUBLEQ architecture - https://github.com/vygr/DawnOS
  10. digicam.love - promotes photography done with old digital cameras - https://digicam.love/
  11. Freewheeling Apps - software that is easy to try out, easy to modify and easy to share - https://freewheelingapps.org/
  12. Gemini - internet technology supporting an electronic library of interconnected text documents - https://gemini.circumlunar.space/
  13. IBNIZ - virtual machine designed for extremely compact low-level audiovisual programs - http://viznut.fi/ibniz/
  14. L5 - A lightweight Processing-like creative coding library designed for old and new computers - https://git.sr.ht/~l5/l5
  15. Mu - a minimal-dependency hobbyist computing stack - https://mu-computing.org/
  16. PostmarketOS - pre-configured Alpine Linux with own packages, that can be installed on smartphones - https://postmarketos.org/
  17. Screenless Office - system for working with media and networks without using a pixel-based display - https://100r.co/site/screenless_office.html
  18. snac - simple, minimalistic ActivityPub instance written in portable C - https://codeberg.org/grunfink/snac
  19. Solar Protocol - a web platform hosted across a network of solar-powered servers - https://solarprotocol.net/
  20. Teliva - fork of Lua 5.1 to encourage end-user programming - https://github.com/akkartik/teliva
  21. The People's Permacomputer - project dedicated to building a 'permacomputer' which will survive societal collapse - https://git.sr.ht/~vidak/peoples-permacomputer/ :contentReference[oaicite:1]{index=1}
  22. Uxn - personal computing stack based on a small virtual machine - https://100r.co/site/uxn.html
  23. Watt Wiser - tools to measure and visualize energy use on desktop computers - https://watt-wiser.org/
  24. What Remains - NES/Famicom game published on recycled game cartridges and EPROMs - https://whatremains.industries/

Characteristics

Permacomputing:

"Properties of permacomputing systems

The principles concretely manifest themselves in various forms so as to highlight the following properties:

  1. accessible: well documented and adaptable to an individual's needs.
  2. compatible: works on a variety of architectures.
  3. efficient: uses as little resources (power, memory, etc) as possible (minimization).
  4. flexible: modular, portable, adapts to various use-cases.
  5. resilient: repairable, offline-first, low-maintenance, designed for disassembly, planned for longevity, #maximized lifespan, descent-friendly or designed for descent


Some additional concerns are of indirect interest because they impose costs on the entire end-to-end process of software creation:

  1. it's bootstrapped from machine code without circular reasoning (bootstrappable builds)
  2. it's obvious what source code went into it (reproducible builds)
  3. it's easy to audit its source code, including all dependencies . "

(https://permacomputing.net/permacomputing/)