Wild Cloud is a community-driven, open source project.
## Ask
Want to get in touch with the founder and developer of Wild Cloud v1? Email paul@payne.io.
## Discuss
The [Civil Society Technology Foundation (CSTF)](https://civilsociety.dev) provides a [forum for Wild Cloud community discussion](https://forum.civilsociety.dev/c/wild-cloud/). All are welcome! It's kinda quiet there right now, but hey, if you post now you'll always be remembered as a founding contributor!
## Hack
If you're ready to jump into development, join our project at https://git.civilsociety.dev/wild-cloud. We accept community pull requests related to any of these issues.
If you're ready to jump into development, join our project at https://git.civilsociety.dev/wild-cloud. In addition to source code, you'll find a list of our current [issues](https://git.civilsociety.dev/wild-cloud/issues). We accept community pull requests related to any of these issues.
@@ -50,7 +50,7 @@ You can put it in any directory. Here we show an example if you want to make a d
```bash
mkdir -p ~/my-wild-cloud
cd ~/my-wild-cloud
wild-cloud-scaffold
wild-init
```
That's it! Your wild cloud operator machine is ready to go! Most of the rest of the instructions in this guide will assume you are working within this directory.
@@ -17,16 +17,12 @@ You will be using a USB key to boot each of your cluster machines. Let's create
From your wild cloud home, run:
```bash
# Upload schematic configuration to get schematic ID from the Talos ISO service.
wild-talos-schema
# Download custom ISO with system extensions.
wild-cluster-node-boot-assets-download
```
This will download all the Talos ISOs for your wild cloud configuration.
This will download a Talos ISO you can use to create a USB drive.
The custom ISO includes system extensions needed for a wild cloud cluster and is saved to `.wildcloud/iso/talos-v<VERSION>-metal-amd64.iso`.
The custom ISO includes system extensions needed for a wild cloud cluster and is saved to `.wildcloud/node-boot-assets/<schematicId>/iso/talos-v<VERSION>-metal-amd64.iso`.
### Copy ISO to a USB drive
@@ -45,8 +41,9 @@ sync
**⚠️ Warning**: Double-check the device path (`/dev/sdX`). Writing to the wrong device will destroy data!
TO DO: Look into some utilities (Balena Etcher, Rufus, etc.) to make this simpler/safer.
{{<go-deeper>}}
Note: Balena Etcher can also be used to create a bootable USB drive from the ISO.
{{</go-deeper>}}
## How to install Talos OS on a machine
@@ -107,7 +104,7 @@ wild-setup-services
When the setup is finished, you can test your installation with:
summary: "Git is more than just a version control system; it embodies principles of decentralization, resilience, and user self-determination. This article explores how Git's distributed architecture aligns with the values of civil society organizations, enabling them to maintain control over their digital infrastructure."
---
## Introduction
## Git: The Version Control Superpower
Version control systems are the backbone of modern software development, enabling collaboration, preserving history, and managing complexity. Among these tools, Git stands apart—not just as the most widely used version control system, but as a technology that fundamentally aligns with principles of decentralization, resilience, and user self-determination.
Most of us have, at some point, saved a file as `project.doc`, then later as `project-final.doc`, then finally as `project-final-final2.doc`. 😅 That mess is what Git was created to solve. Git is a **version control system**—a tool that lets you track every change to your files, collaborate safely with others, and rewind history if something goes wrong.
For civil society organizations, Git represents much more than a development tool. It embodies a different way of thinking about collaboration—one based on distributed trust, transparent history, and resilience against centralized control. In this article, we explore what Git is, how it works, and why its approach to distributed collaboration matters for organizations committed to digital self-determination.
{{<definition>}}
**Version Control System (VCS)**: Software that records changes to files over time so you can recall specific versions later. It allows multiple people to work on the same files without overwriting each other’s work.
{{</definition>}}
## What Is Git?
---
Git is a distributed version control system created by Linus Torvalds (the original developer of Linux) in 2005. Unlike previous version control systems that relied on centralized servers, Git gives every participant a complete copy of the project's entire history. This seemingly simple architectural choice has profound implications for how collaboration works.
## A little backstory
### Key Characteristics of Git
In 2005, Linus Torvalds (the creator of Linux) needed a better way for thousands of people all over the world to contribute code to the Linux kernel without stepping on each other’s toes. He wrote Git in a few weeks, and it became the backbone of modern software development. Today, Git powers not just Linux, but nearly every open-source project, GitHub, GitLab, and the tools you’ll use in your Wild Cloud journey.
- **Distributed**: Every repository contains the full history, enabling offline work and eliminating single points of failure
- **Content-addressed**: Files are identified by cryptographic hashes of their content, ensuring integrity
- **Branching-focused**: Multiple lines of development can proceed in parallel, merging when ready
- **History-preserving**: Changes are recorded as an immutable chain, creating transparency and accountability
- **Non-hierarchical**: Any repository can synchronize with any other, without requiring a central authority
{{<go-deeper>}}
Want to see how radical Git was at the time? Check out Linus’s announcement on the [Linux Kernel mailing list](https://lwn.net/Articles/130681/). His blunt, hackerish style makes it clear he was building this tool to scratch a serious itch.
{{</go-deeper>}}
These characteristics create a system where collaboration is possible without requiring trust in a central authority—a principle that resonates deeply with civil society's need for resilient, independent systems.
---
### How Git Differs from Centralized Systems
## Why Git matters for you
To understand Git's significance, it helps to contrast it with centralized approaches:
Even if you’re not a professional software developer, Git is a huge enabler. It means:
| Aspect | Centralized Version Control | Git (Distributed Version Control) |
| **Network Requirement** | Constant connection needed | Can work offline with full history |
| **Failure Points** | Central server is critical | Multiple complete copies exist |
| **Control** | Administrator manages access | Each user controls their copy |
| **Workflow** | Linear and prescribed | Flexible and adaptable |
| **Trust Model** | Trust in central authority | Trust distributed across network |
* Every change you make is recorded (and reversible).
* You can experiment in a “branch” without breaking your main project.
* Collaborating with friends or colleagues is safe and trackable.
* Your entire history can be backed up anywhere (including in your wild cloud).
This shift from centralized to distributed architecture mirrors many of the broader transitions civil society organizations seek in digital infrastructure—moving from single points of control to resilient networks of peers.
{{<bring-it-home>}}
When you’re running Wild Cloud, you’ll use Git to fetch software, manage your configurations, and share your work with the community. It’s the glue that holds your setup scripts together.
{{</bring-it-home>}}
## Technical Foundations
---
Understanding Git's technical approach helps clarify why it's so valuable for sovereign technology practices.
## Getting started with Git
### The Object Model
### Install Git
At its core, Git stores four types of objects:
On Ubuntu or Debian:
1.**Blobs**: The content of files
2.**Trees**: Directories of blobs and other trees
3.**Commits**: Snapshots of the repository at a point in time
4.**Tags**: Named references to specific commits
```bash
sudo apt update
sudo apt install git
```
These objects form a content-addressed database where each object is identified by its SHA-1 hash. This cryptographic approach ensures:
On macOS (with Homebrew):
- Content integrity (changes are immediately detectable)
- Deduplication (identical content is stored only once)
- Authentication (commits can be cryptographically signed)
- Verification (history cannot be silently altered)
```bash
brew install git
```
### The Distributed Model
Verify the install:
Git's distributed nature means:
```bash
git --version
```
- Each repository contains all objects and history
- No single repository has special status
- Changes are exchanged between peers through "remotes"
- Any repository can serve as a backup for the entire project
### Configure Git
This architecture creates resilience through redundancy—exactly the quality that civil society organizations need in potentially challenging environments.
Set your identity:
## Git for Civil Society
```bash
git config --global user.name "Your Name"
git config --global user.email "you@example.com"
```
For civil society organizations, Git offers specific benefits that align with core values and practical needs:
### Make your first repo
### 1. Resilience Against Disruption
```bash
mkdir my-first-git
cd my-first-git
git init
```
Git's distributed nature means:
Add a file:
- Work continues even if internet connectivity is limited or monitored
- No single point of failure can eliminate access to code or documents
- Information can be shared through multiple channels when needed
- Organizations can maintain control of their projects regardless of hosting platform decisions
```bash
echo"Hello Wild Cloud" > readme.txt
git add readme.txt
git commit -m "Add first file"
```
In contexts where infrastructure may be unreliable or subject to interference, this resilience is invaluable.
That’s it! You’ve captured your first snapshot of history. 🎉
### 2. Self-Determination and Control
---
Git provides complete control over:
## ⚠️ Warning
- Where and how repositories are hosted
- Who has access to what parts of the codebase
- How contributions are reviewed and incorporated
- What external dependencies are included
Git is powerful but unforgiving: commands like `git reset --hard` can **destroy uncommitted work** permanently. Always double-check before running destructive commands.
This self-determination means organizations aren't dependent on the policies or availability of any particular service provider.
---
### 3. Transparency and Accountability
## Next Steps
Git's immutable history creates:
* Try editing `readme.txt`, then running `git diff` to see your changes.
* Explore branching with `git checkout -b new-idea`.
* Back up your repo by pushing to [GitHub](https://github.com/) or hosting your own Git server in your wild cloud.
- Clear attribution of changes to specific contributors
- Permanent record of development decisions
- Ability to audit exactly when and how code evolved
- Cryptographic verification of who made what changes
---
These transparency features support organizational accountability and help build trust in critical systems.
### 4. Collaborative Without Centralization
Git enables collaboration models that:
- Don't require hierarchical permissions
- Allow multiple approaches to develop in parallel
- Support both tight coordination and loose federation
- Function across organizational boundaries
This flexibility accommodates diverse organizational structures and coalition-building.
### 5. Future-Proof Documentation
Git repositories provide:
- Complete historical context for decisions
- Self-contained documentation that travels with the code
- Independence from any particular documentation platform
- Resilience against link rot and lost references
Organizations investing in long-term projects benefit from this comprehensive approach to institutional memory.
## Beyond Code: Git for Documents and Data
While initially designed for source code, Git has proven valuable for many other content types:
### Documents and Publications
Many organizations use Git for:
- Policy documents with transparent revision history
- Collaborative writing with clear attribution
- Website content with staging and review
- Reports that show how analysis evolved
Tools like Markdown, Asciidoc, and LaTeX work particularly well with Git, allowing documents to benefit from the same workflows as code.
### Data and Research
Git can manage:
- Datasets with clear provenance tracking
- Analysis scripts alongside their data
- Research findings with reproducible methods
- Configuration files with documented changes
While large binary files require special handling, Git-LFS (Large File Storage) extends Git's capabilities to manage these efficiently.
### Infrastructure as Code
Git is essential for:
- Server configurations that can be tested and rolled back
- Network setups with documented changes
- Deployment scripts with security reviews
- Container definitions with audit trails
This "infrastructure as code" approach lets organizations apply the same governance to their infrastructure that they apply to their software.
## Common Git Workflows for Civil Society
Organizations can adapt Git workflows to match their needs and structures:
### Lightweight Personal Projects
For individual work or small teams:
- Simple branching strategy (main branch with feature branches)
- Direct pushes for trusted contributors
- Minimal process overhead
- Local repositories with occasional synchronization
### Collaborative Open Projects
For community projects with multiple contributors:
- Fork and pull request model
- Review requirements for all changes
- Issue tracking integrated with development
- Public repositories on platforms like GitHub, GitLab, or self-hosted Gitea
### Secure Sensitive Projects
For projects handling sensitive information:
- Careful access control with signed commits
- Self-hosted repositories with controlled access
- Encrypted storage of sensitive configuration
- Clear separation between public and private components
## Misconceptions About Git
Several misconceptions can discourage adoption:
### "Git Is Only for Programmers"
**Reality**: While Git emerged from software development, its principles apply to any collaborative work that benefits from version history. Many non-technical teams use Git for documentation, policy development, and publishing workflows.
### "Git Is Too Complicated"
**Reality**: Git's power does come with complexity, but:
- Basic workflows require learning only a few commands
- Graphical interfaces make common operations accessible
- The learning curve reflects Git's power and flexibility
- Skills developed transfer across projects and organizations
### "We Need a Central Server Anyway"
**Reality**: While many organizations use platforms like GitHub or GitLab, these are conveniences, not requirements. Git can function entirely via email, USB drives, or direct connections when needed, and any Git repository can serve as a temporary "hub" when appropriate.
## Getting Started with Git
For civil society organizations exploring Git, we recommend:
1.**Start small**: Use Git for a defined project with clear boundaries
2.**Focus on fundamentals**: Learn core concepts rather than memorizing commands
3.**Choose appropriate tools**: Use graphical interfaces when they help
4.**Create conventions**: Establish clear norms for commit messages and branching
5.**Build skills gradually**: Add more advanced workflows as teams become comfortable
The Civil Society Technology Foundation can provide guidance on Git adoption strategies tailored to organizational needs and constraints.
## Beyond Git: The Distributed Collaboration Ecosystem
Git has inspired a broader ecosystem of tools supporting distributed, sovereign approaches:
- **Decentralized forges** like Radicle provide Git collaboration without central servers
- **Offline-first tools** extend Git's model to other content types
- **Peer-to-peer synchronization** enables collaboration without central infrastructure
- **Signed commits** provide strong attribution even in untrusted environments
These innovations continue to expand Git's relevance for civil society's digital infrastructure.
## Case Study: Resilient Documentation in Challenging Environments
Organizations working in regions with internet censorship or surveillance have used Git to:
- Share information through multiple channels when primary methods are restricted
- Preserve historical records that might otherwise be vulnerable to tampering
- Collaborate across geographical and technical boundaries
By distributing repositories across multiple participants, these organizations ensure their work continues regardless of external pressures.
## Conclusion
Git represents more than just a tool—it embodies an approach to collaboration built on principles that civil society defends: distributed authority, transparent history, resilient systems, and user self-determination. By adopting Git and its associated practices, organizations don't just improve their technical workflows; they align their operational methods with their values.
The Civil Society Technology Foundation recognizes Git as a foundational technology for independent civil society infrastructure, enabling transparent collaboration without creating new dependencies or vulnerabilities.
In a digital landscape increasingly dominated by centralized platforms and services, Git offers a tested, proven approach to collaboration that maintains independence, builds institutional memory, and creates resilience against disruption—not as a technical preference, but as an expression of civil society's core principles in code.
👉 So, Git isn’t just for coders—it’s for anyone who wants to keep control of their digital work. Once you start using it, you may wonder how you ever kept track of files without it.
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
