Add some setup and learning content.

content/_index.md

@@ -5,8 +5,29 @@ description: Wild Cloud is an Open Source, self-hosted, sovereign cloud platform
 
 ![Your Wild Cloud Logo](wild-cloud.svg)
 
-```bash {class="my-class" id="my-codeblock" lineNos=inline tabWidth=2}
-wild-setup
-```
 
-Coming soon...
+Wild clouds are Open Source, self-hosted, independent platforms for hosting your applications and services. Your wild cloud is your own private data center where you can host your own applications.
+
+You can have your own wild cloud for the price of a smart phone and an Internet connection. You can scale your wild cloud as large as you like.
+
+While not a consumer product (yet), Wild Cloud aims to make self-hosting accessible to every individual and organization. Wild Cloud is a non-profit, community-driven project, educational in nature, designed to empower society to directly control its own data and services.
+
+This is a wild cloud:
+
+![A Wild Cloud](/img/wc01.jpg)
+
+This is also a wild cloud:
+
+![A Wild Cloud](/img/wc02.jpg)
+
+## Apps
+
+In addition to helping you set up and manager your cloud, Wild Cloud gives you a set of Open Source applications you can run on your cloud.
+
+## Get started
+
+We're in the early days of the Wild Cloud project, yet we already have two functional "Proof of concept" clouds. In fact, all Wild Cloud and CSTF sites and services are running on our PoC wild cloud. The concept works. If you are an experienced developer, you can check out the software and start building your own wild cloud. Our next milestone is to continue ironing out the software and educational materials so that we can invite early adopters to start building their own wild clouds.
+
+If you would like to get us to this next milestone, join our [developer community](https://git.civilsociety.dev/CSTF/wild-cloud).
+
+If you would like to help the project move forward in other ways, check out our parent org at [Civil Society Tech Foundation](https://civilsociety.dev) and consider supporting us with a donation or connecting us with interested partners.

content/contribute/index.md

@@ -4,4 +4,4 @@ date = '2025-06-09'
 draft = false
 +++
 
-Wild Cloud is a community-driven, open source project. Join us at https://github.com/civil-society-dev/wild-cloud.
+Wild Cloud is a community-driven, open source project. Join us at https://git.civilsociety.dev/CSTF/wild-cloud.

content/get-started/dns-server-setup/index.md

@@ -0,0 +1,25 @@
++++
+title = "Setup Wild Cloud"
+date = '2025-06-09'
+draft = false
++++
+
+
+## Get your hardware
+
+Make sure you have a dedicated machine for your DNS server. It can be tiny, like an Orange Pi Zero.
+
+## Install your OS
+
+- Install another Debian-based Linux machine on your LAN (e.g. Debian or Ubuntu). 
+- Record it's IP address.
+
+## Install the DNS software
+
+- Run `wild-dnsmasq-install` from your operator machine.
+
+## Update your LAN router
+
+- Log in to your LAN router's web interface.
+- Find the DHCP settings and reserve the IP address you recorded for your DNS server.
+- Set the DNS server for your LAN to the IP address of your DNS server.

content/get-started/get-a-domain-name/index.md

@@ -0,0 +1,18 @@
++++
+title = "Get a Domain Name"
+date = '2025-06-09'
+draft = false
++++
+
+## Get a Domain Name
+
+You'll need to use CloudFlare.
+
+Instructions...
+1. Go to [CloudFlare](https://www.cloudflare.com/) and create an account.
+2. If you don't already have a domain name, you can purchase one through CloudFlare.
+3. If you do have one, you can have CloudFlare manage your DNS records for you. (instructions)
+
+## Set up your LAN router
+
+- DynamicDNS

content/get-started/hardware/index.md

@@ -0,0 +1,73 @@
++++
+title = "Hardware"
+date = '2025-06-09'
+draft = false
++++
+
+## Get your hardware
+
+A basic wild cloud requires 8 computers, a network switch, a battery backup, and an Internet connection.
+
+Six of the computers run Talos Linux and are your "cluster nodes". One computer will run your local network's name server so you can access internal cloud applications. The last computer is just used to manage your cluster. Most of these computers can be small or old machines, and they are all managed by Wild Cloud, so don't think it's too expensive or complicated to get started. A really useful wild cloud can be built for less than the price of a new smart phone.
+
+{{<alert>}}
+In computing, the word "machine" goes back to Alan Turing’s 1936 concept of the ‘Turing machine,’ and to early electromechanical computers like ENIAC that were literally giant calculating machines. Today, in Kubernetes and cloud systems, like your wild cloud, we still use the word "machine" to mean any physical or virtual computer that runs workloads.
+{{</alert>}}
+
+## Your "operator" machine
+
+_You_ are the operator of your wild cloud, and you will need a computer to manage it. This can be any computer that you use regularly, such as a laptop or desktop. It does not need to be powerful. Wild Cloud management software is currently only tested on Ubuntu Linux, but it should work on any Linux or MacOS machine. 
+
+## LAN Router
+
+Your LAN router is the central hub for your wild cloud network. It connects all of your machines to each other and to the Internet. We recommend the GL-iNet Flint 2 router. Why? [read more]
+
+## DNS machine
+
+You'll need a tiny computer to run your local DNS server. This can be a Raspberry Pi or any other small computer that can run Linux. It does not need to be powerful, as it will only handle a small amount of name lookups for internal use of your cloud. Here's a picture on an Orange Pi Zero running a wild cloud DNS server. It cost $40.
+
+![Orange Pi Zero](/img/dns-machine.jpg)
+
+## Cluster control nodes (x3)
+
+A wild cloud computer cluster requires three control nodes. These are the machines that run Talos Linux and Kubernetes software. These computers all talk to each other and manage the cluster on your behalf. They will schedule all of your applications and make sure they keep running properly. These computers don't need a lot of horsepower or memory or disk space as they are only doing one thing. Micro PCs make great control nodes because they are inexpensive, quiet, and use very little power. 
+
+Here is a picture of three BeeLink Mini S machines, each costing a little over $120.
+
+![BeeLink Mini S](/img/control-nodes-beelinks.jpg)
+
+And here is a picture of three old Shuttle PCs that I found in the trash at work. They're perfect.
+
+![Shuttle PCs](/img/control-nodes-shuttles.jpg)
+
+## Worker nodes (xN)
+
+Finally, you'll need at least three worker nodes, but you can add as many as you like. We need at least three so the data storage across the nodes can be reliable against any one node failing. A worker node is any computer that runs Talos Linux and Kubernetes software and your applications will be automatically run on them. You can start with smaller machines to handle many different kinds of applications, and you can attach larger, more powerful machines for more demanding applications later (like video processing or AI/machine learning).
+
+This wild cloud has three worker nodes, one is a big desktop PC with a powerful GPU for AI processing, another is a micro PC I purchased for around $500, and the third I bought from a thrift store for $10.
+
+![Worker Nodes](/img/workers.jpg)
+
+## Network switch
+
+A network switch is a device that connects all of the computers in your wild cloud together into a single network. You _could_ use a wireless network, but using a network switch to physically connect your machines together provides more reliability. A simple 8-port "unmanaged" switch is usually sufficient for a basic wild cloud setup, but you can get larger switches if you have more machines.
+
+Here's a picture of a simple 8-port switch that costs around $20:
+
+![Network Switch](/img/switch-2.jpg)
+
+Here's a picture of a larger 16-port switch that costs around $120. This wild cloud is ready for 8 more machines:
+
+![Network Switch](/img/switch-1.jpg)
+
+## Battery Backup
+
+A battery backup (UPS) is an important part of your wild cloud setup. It ensures that your cloud remains operational even during power outages. Look for a UPS that can provide enough power for all of your critical machines for at least a few minutes.
+
+## USB thumb-drives
+
+USB thumb-drives are useful for booting your wild cloud machines and for transferring files between them. Look for USB drives that are at least 32GB in size and have good read/write speeds. A set of three or four is recommended.
+
+## Next Steps
+
+Now that you have your hardware, we can start setting things up! Follow the instructions in the [Setup Wild Cloud](../setup-wild-cloud/) guide to get started.

content/get-started/index.md

@@ -6,4 +6,10 @@ draft = false
 
 _The Wild Cloud project is in active development._
 
-{{< github repo="civil-society-dev/wild-cloud" showThumbnail=true >}}
+1. [Get your hardware](./hardware/)
+2. [Reserve a domain name](./get-a-domain-name/)
+3. [Set up your operator machine](./operator-setup/)
+4. [Set up your DNS server](./dns-server-setup/)
+5. [Set up your Wild Cloud](./setup-wild-cloud/)
+6. [Use your Wild Cloud](./using-wild-cloud/)
+

content/get-started/operator-setup/index.md

@@ -0,0 +1,32 @@
++++
+title = "Operator Setup"
+date = '2025-06-09'
+draft = false
++++
+
+The Wild Cloud software is Open Source and free. All you need to do is download it onto your operator machine, install some other programs we require, and then run the setup script. The setup script walks you through the process of installing your DNS machine, your control nodes, your worker nodes, and then any software you want to run on your cloud.
+
+(This page assumes you already have your hardware ready to set up. If you don't, read [Setting Up Your Hardware](../hardware/)).
+
+
+## Download the Wild Cloud software onto your operator machine
+
+
+Your operator machine should be a Debian-based Linux machine (e.g. Debian or Ubuntu) on your LAN. It's helpful if it has a nice big hard drive you can use for backing up your cloud data.
+
+{{< gitea server="https://git.civilsociety.dev" repo="CSTF/wild-cloud" showThumbnail=true >}}
+
+```bash
+git clone https://git.civilsociety.dev/CSTF/wild-cloud.git
+```
+
+Add the `bin` directory to your path.
+```bash
+export PATH=$PATH:~/wild-cloud/bin
+```
+
+Install dependencies:
+
+```bash
+scripts/setup-utils.sh
+```

content/get-started/setup-wild-cloud/index.md

@@ -0,0 +1,56 @@
++++
+title = "Setup Wild Cloud"
+date = '2025-06-09'
+draft = false
++++
+
+
+## Set up your own Wild Cloud!
+
+That's it! Now you can start setting up your wild cloud!
+
+First, make a directory for your wild cloud home. For example `my-wild-cloud` in your home directory.
+
+```bash
+mkdir ~/my-wild-cloud
+cd ~/my-wild-cloud
+```
+
+Now, you can start the setup process! Just run...
+
+```bash
+wild-setup
+```
+
+The rest of this page walks you through a few of the setup details.
+
+### Install your control nodes
+
+- Make a Talos USB key.
+  `wild-cluster-node-boot-assets`
+- Instal Talos OS with your USB key.
+- It will boot into "maintenance mode". Use the IP address it displays in `wild-setup`.
+- Repeat for the other two control nodes.
+
+### Install your worker nodes
+
+- Install Talos OS with your USB key.
+- It will boot into "maintenance mode". Use the IP address it displays in `wild-setup`.
+- Repeat for as many additional worker nodes as you'd like (three minimum).
+
+### Install cluster services
+
+After your control and worker nodes are installed, `wild-setup` will automatically install all of your wild cloud's cluster services.
+
+
+## Check your installation
+
+When the setup is finished, you can test your installation with:
+
+```bash
+wild-status
+```
+
+## Next Steps
+
+Now that you have your Wild Cloud set up, you can start using it! Follow the instructions in the [Using Wild Cloud](../using-wild-cloud/) guide to get started with deploying applications and managing your cloud environment.

content/get-started/using-wild-cloud/index.md

@@ -0,0 +1,25 @@
++++
+title = "Use Your Wild Cloud"
+date = '2025-06-09'
+draft = false
++++
+
+## Installing Applications
+
+`wild-app-fetch <app-name>`
+`wild-app-install <app-name>`
+
+Configure
+
+`wild-app-deploy <app-name>`
+
+## Customizing your apps
+
+
+## Upgrade your apps
+
+
+## Making backups
+
+
+## Restoring backups

content/learning/_index.md

@@ -0,0 +1,9 @@
+---
+title: "Learning"
+cardView: true
+cascade:
+  showReadingTime: true
+  showWordCount: true
+---
+
+Resources for building technical skills and learning about your Wild Cloud.

content/learning/git/index.md

@@ -0,0 +1,261 @@
+---
+title: "Git"
+date: 2025-01-15
+featureImageCaption: Author unknown. (https://commons.wikimedia.org/wiki/File:Linus-Torvalds.jpeg), “Linus Torvalds”, https://creativecommons.org/licenses/by-sa/3.0/legalcode
+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
+
+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.
+
+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.
+
+## 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.
+
+### Key Characteristics of Git
+
+- **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
+
+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
+
+To understand Git's significance, it helps to contrast it with centralized approaches:
+
+| 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   |
+
+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.
+
+## Technical Foundations
+
+Understanding Git's technical approach helps clarify why it's so valuable for sovereign technology practices.
+
+### The Object Model
+
+At its core, Git stores four types of objects:
+
+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
+
+These objects form a content-addressed database where each object is identified by its SHA-1 hash. This cryptographic approach ensures:
+
+- 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)
+
+### The Distributed Model
+
+Git's distributed nature means:
+
+- 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
+
+This architecture creates resilience through redundancy—exactly the quality that civil society organizations need in potentially challenging environments.
+
+## Git for Civil Society
+
+For civil society organizations, Git offers specific benefits that align with core values and practical needs:
+
+### 1. Resilience Against Disruption
+
+Git's distributed nature means:
+
+- 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
+
+In contexts where infrastructure may be unreliable or subject to interference, this resilience is invaluable.
+
+### 2. Self-Determination and Control
+
+Git provides complete control over:
+
+- 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
+
+This self-determination means organizations aren't dependent on the policies or availability of any particular service provider.
+
+### 3. Transparency and Accountability
+
+Git's immutable history creates:
+
+- 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:
+
+- Maintain critical documentation despite platform blocks
+- 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.

content/learning/internet/index.md

@@ -0,0 +1,95 @@
+---
+title: "The Internet"
+date: 2025-08-17
+featureImageCaption: ITU. https://bbmaps.itu.int/bbmaps/. Captured 2025-07-09.
+summary: What even _is_ the Internet?
+---
+
+## Introduction
+
+Many of us don't even remember a time before the Internet, so we kind of just think of it as a natural part of our lives that is in some way _behind_ things like a force of the universe or something.
+
+Simultaneously, most of us don't ever _do_ anything with the Internet other than use it to connect our devices to services from companies.
+
+This can all create a dependency mindset.
+
+Part of Wild Cloud's purpose is to demystify technology and empower individuals and communities to take control of their digital lives. To do that, let's start with the Internet. What even is it? Really?
+
+It's not really _that_ complicated.
+
+## Letting computers talk to each other (networking)
+
+At its core, the Internet is simply a bunch of computers that are connected together so they can pass data between them. People thought this was a good idea from the beginning with computers, but it was always hard to physically connect them, the data moved slow, and it was hard to make sure that the data got to to the other side uncorrupted. Also, even if you get two computers connected with a wire between them, what if you want to connect a dozen computers? Do you run a wire through all of them like a big circle or do you make it like a spider web with one sort of "hub" in the middle? And what if you want to connect one group to another group?
+
+{{<alert icon="circle-info">}}
+**Network**: A group of computers connected together so they can pass data around.
+{{</alert>}}
+
+Lot's of people and companies worked on a lot of ideas for a few decades to solve all these challenges. In 1969, some people working at UCLA, Stanford, UC Santa Barbara, and the University of Utah figured out a way to connect their computers together to pass data around. Do you think they knew at that moment that they had created something that would connect most of the computers in the world together!?
+
+{{<alert icon="circle-info">}}
+**ARPANET**: The original network that connected these early computers together, and the precursor to the modern Internet. This public research project was funded by the U.S. Department of Defense's Advanced Research Projects Agency (ARPA), so they named their network ARPANET.
+{{</alert>}}
+
+Over the next ten years, they connected more than 200 nodes (the name for a computer that is part of a network). Some as far away as London and Norway.
+
+{{<alert icon="circle-info">}}
+**Node**: A computer that is part of a network (a "network node").
+{{</alert>}}
+
+
+{{<alert icon="heart" iconColor="red" cardColor="pink">}}
+Your wild cloud is a network of at least 8 nodes all running on your Local Area Network (LAN) and connected through a router to the Internet, also known as the Wide Area Network (WAN).
+{{</alert>}}
+
+
+## Introducing a common language (TCP/IP)
+
+But, in the 1970s, other groups kept working on other ways to connect computers, and they developed their own networking protocols that were incompatible with the ARPANET. How could these different networks communicate with each other?
+
+{{<alert icon="circle-info">}}
+**Protocol**: An agreed-upon way of doing something. If two people, or companies, or schools, **or machines**, use the same protocol, they can work together. People or machines using different protocols have a hard time getting along. Two computers that can talk together on a network are using the same "network protocol".
+{{</alert>}}
+
+So, they figured out a common language to connect all these different networks, named it TCP/IP, and switched the ARPANET over to it in 1983.
+
+{{<alert icon="circle-info">}}
+**TCP/IP**: The common language that connects different networks together. It if flexible because it breaks the problem into two parts, the Transmission Control Protocol (TCP) and the Internet Protocol (IP).
+{{</alert>}}
+
+{{<alert icon="graduation-cap" cardColor="#ffdf78ff" iconColor="#fa6b0cff">}}
+Vint Cerf and Bob Kahn developed TCP/IP, and explained how it works in their paper, [“A Protocol for Packet Network Intercommunication”](/papers/cerf74.pdf), which was published in IEEE Transactions on Communications, May 1974. Want to have some fun digging in? Try uploading this paper to ChatGPT or some other assistant and have a conversation about it! You'll know more about networking in an afternoon than many career software engineers. 😁
+{{</alert>}}
+
+TCP/IP gives every node on the Internet a unique address you can use to find it and talk to it. These are called "IP Addresses". Every device that talks to another device on the Internet has an IP address. These are the "###.###.###.###" format numbers where section is a number from 0-255. So, 192.168.1.0 is an IP address, and so is 10.10.10.10, and so it 56.122.200.27. TCP/IP can route data to your device just using its address... very similar to how letters get to your mailbox.
+
+{{<alert icon="circle-info">}}
+**IP Address**: A unique string of numbers separated by periods that identifies _every_ computer on a TCP/IP network like the Internet. For example, `192.168.1.1` is an IP address.
+{{</alert>}}
+
+{{<alert icon="heart" iconColor="red" cardColor="pink">}}
+Every computer that is a part of your wild cloud has a unique, local, IP address. Your LAN router, which also has an IP address, assigns unique IP addresses to each device on your LAN and keeps track of them.
+{{</alert>}}
+
+
+## Making it friendly (DNS)
+
+But people don't think in numbers, people think in words or names, so a guy at the University of Southern California figured out a system he called the Domain Name System (DNS) in 1983. His system allowed IP addresses to be mapped to "domain names", so that now, somebody could use `wikipedia.org` instead of `198.35.26.96` (see that's easier to remember!) to address a particular computer. The DNS system is particularly interesting because it's design is much of the reason we have a resilient, distributed, non-centrally controlled Internet today. Any individual or organization can register their own unique domain name and control what computers IP addresses it maps to.
+
+{{<alert icon="circle-info">}}
+**DNS**: The Domain Name System, which maps IP addresses to human-readable domain names (like `wikipedia.org`). 
+{{</alert>}}
+
+{{<alert icon="graduation-cap" cardColor="#ffdf78ff" iconColor="#fa6b0cff">}}
+Paul Mockapetris wrote up his design in a working group he was a part of in 1983. You can read his paper ["DOMAIN NAMES - CONCEPTS and FACILITIES"](/papers/rfc882.txt.pdf). The design has been adapted a bit over the years, but if you spent an afternoon with ChatGPT digging into this paper, you'll know more about how the Internet works almost anyone. 😁
+{{</alert>}}
+
+{{<alert icon="heart" iconColor="red" cardColor="pink">}}
+When you set up a wild cloud, you will register a domain name at a domain registrar (Wild Cloud currently supports CloudFlare). You will then map this domain name to the applications on your wild cloud.
+{{</alert>}}
+
+
+## Conclusion
+
+So what is the Internet? It's just a bunch of computers connected together, all speaking the same language (TCP/IP) and using a system (DNS) to find each other. It's not something that is "out there"; it's right here, in your home, in your devices, and in your wild cloud.
+

content/learning/linux/index.md

@@ -0,0 +1,81 @@
+---
+title: "Linux: The Open Operating System"
+date: 2025-01-15
+featureImageCaption: "Photo by <a href=\"https://unsplash.com/@wwarby?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash\">William Warby</a> on <a href=\"https://unsplash.com/photos/a-penguin-is-standing-on-a-rocky-area-mlDxrRUuDxc?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash\">Unsplash</a>"
+summary: "Linux is more than just an operating system; it is a cornerstone of digital self-determination for civil society organizations. This article explores how Linux empowers communities to reclaim control over their technology, ensuring independence, security, and adaptability in an increasingly centralized digital landscape."
+---
+
+## Operating System?
+
+Back in the days before every desktop and laptop was sold as a "PC" or an "Apple", and every phone was an "Android" or an "iPhone", people had a better idea of what an "operating system" was. As the tech landscape consolidated around a few dominant players, their brands hid the reality that hardware and software were different things and that users had more than two choices. In fact, today, it is difficult to even find a computer that isn't pre-installed with one of the two dominant operating systems, Windows or macOS.
+
+{{<alert icon="circle-info">}}
+The **operating** system is the name for the core software that makes individual hardware components of a computer work together, gives the user a way to interact with them, and makes it easy to write and run software applications on top of them. Operating systems make storage drives accessible as folders and files, turns screens into desktops, and allows you to use keyboards and mice to drive things. Operating systems load programs into memory and execute them on purpose-tailored hardware chips like central processing units (CPUs), graphical processing units (GPUs), and neural processing units (NPUs).
+{{</alert>}}
+
+Apple makes all of their own hardware and they work hard to only allow only _their_ operating system, macOS run on it. Most of the rest of the hardware on the market, though, was created by a bunch of different companies who, in order to and compete, made their hardware more openly, collaborating together to specify standard ways of using and assembling their various components. Before Microsoft there were dozens of different operating systems that worked with this open hardware. Microsoft introduced one of the first text-based operating systems that could run on IBM and Intel hardware in 1982 (MSDOS), and their graphical operating systems (Windows 3.1) in 1993 and, through savvy business and legal positioning came to be the default operating system on over 90% of all personal computers.
+
+## Linux?
+
+Even if you're old enough to remember all of this, you might still be surprised that the majority of the world's computers actually __do not__ run Windows or macOS, but some variant of the operating system named Linux. You may be even more surprised to learn that Linux wasn't made by a mega-corporation but freely, as a public good, by a community of developers.
+
+Richard Stallman organized the project that created Linux (the GNU Project) and the foundation that supported it (the Free Software Foundation) in 1983. Linus Torvalds created the core Linux kernel in 1991. The first "system-ready" version of Linux was released in 1992. Over 200 people contributed to its development and it was almost entirely community-funded.
+
+Android _is_ a version of Linux. ChromeOS is a version of Linux. Smart TVs use Linux. The vast majority of all computer run on the major cloud providers (Amazon Web Service, Google Cloud, even Microsoft Azure) run Linux. All of the computers that direct Internet around the world run linux. Every single one of the worlds top 500 supercomputers runs Linux. macOS itself, interestingly, shares many of the same underlying technologies as Linux (after Apple gave up on their fully custom OS) and Windows 10 started shipping Linux as part of their OS.
+
+It's safe to say that Linux powers the world, and, it powers Wild Cloud.
+
+## Linux for Wild Cloud
+
+Wild Cloud, at the time of this writing, uses several versions of Linux.
+
+For your operator machine, we recommend using [Ubuntu Linux](https://ubuntu.com/download). Though the Wild Cloud code may run on other distributions of Linux (especially Debian varieties), and we aim to support multiple distributions in the future, we are currently focused on Ubuntu.
+
+All of your Wild Cloud's control and worker nodes run Talos Linux. Talos is a minimal, secure Linux distribution designed for Kubernetes and cloud-native environments such as Wild Cloud.
+
+## Installing Ubuntu
+
+### On Windows
+
+If you are running a version of Windows 10 or 11, you can use the [Windows Subsystem for Linux (WSL)](https://learn.microsoft.com/en-us/windows/wsl/about) to run Ubuntu alongside your existing Windows installation. Wild Cloud operation works perfectly fine in WSL.
+
+To install Ubuntu on WSL, follow these steps:
+
+1. Open the Microsoft Store and search for "Ubuntu".
+2. Select a recent version of Ubuntu you want to install and click "Install".
+3. Once the installation is complete, launch Ubuntu from the Start menu.
+4. Follow the prompts to set up your new Ubuntu installation.
+
+### On macOS
+
+If you are using macOS, you can install Ubuntu in a virtual machine using software like VirtualBox or VMware Fusion. This allows you to run Ubuntu alongside your existing macOS installation.
+
+To install Ubuntu on a virtual machine, follow these steps:
+
+1. Download [the Ubuntu ISO](https://ubuntu.com/download/desktop) (a single big file that contains the entire Ubuntu installation) from the official website.
+2. Install [VirtualBox](https://www.virtualbox.org/wiki/Downloads) or VMware Fusion on your Mac.
+3. Create a new virtual machine and select the Ubuntu ISO as the installation media.
+4. Follow the prompts to set up your new Ubuntu installation.
+
+### The best way: just Ubuntu
+
+Wild Cloud recommends installing Ubuntu directly on a dedicated computer to be your operator machine. This provides the best performance and compatibility for running Wild Cloud operations.
+
+{{<alert icon="circle-info">}}
+When you install Ubuntu directly on a computer without using WSL or a virtual machine, it's known as installing on "**bare metal**". ⚡
+{{</alert>}}
+
+You can use just about any desktop or laptop computer made in the last 10 years as your operator machine. You can't install Ubuntu on Apple hardware, though. Just keep in mind you will probably want a lot of disk space for backups of your Wild Cloud either on your operator machine or on an attached external drive.
+
+To install Ubuntu on a dedicated machine, follow these steps:
+
+1. Download a recent Ubuntu [ISO from the official website](https://ubuntu.com/download/desktop).
+2. Install [balenaEtcher](https://etcher.balena.io/) following instructions on their website. balenaEtcher will allow you to create a bootable thumb-drive from the Ubuntu ISO file that you can use to install Ubuntu on your operator machine.
+3. Boot the dedicated machine from the USB drive. Many computers will allow you to do this by simply inserting the USB drive and restarting the computer. Some computers are not set to boot from the USB drive, though, so you'll need to access the boot menu (usually by pressing a key like F12, Esc, or Del immediately after turning on the computer) and select the USB drive as the boot device. If you can't figure out how to get to the boot menu, search for your computer model + "boot menu" the the search engine of your choice.
+4. Follow the prompts to install Ubuntu on the dedicated machine. There aren't a ton of options to pick and it usually doesn't take long, maybe a half-hour.
+
+{{<alert icon="heart" iconColor="red" cardColor="pink">}}
+You will be doing everything to operate your Wild Cloud from your operator machine. Treat yourself and make it a nice one!
+{{</alert>}}
+
+🛟 Need help with these instructions? Ask questions in the [Wild Cloud forum](https://forum.civilsociety.dev/t/wild-cloud-support/15).