Git turned twenty this year, and the pitch on git-scm.com still reads like a dare: a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. No login. No cloud. No monthly seat. Linus Torvalds wrote the first version in 2005 to wrangle the Linux kernel when the tool he’d been using pulled its free licence; Junio Hamano has maintained it ever since. That maintenance — twenty years of keeping one boring, bomb-proof thing boring and bomb-proof — is the actual engineering here, not the initial hack.

Architects mostly meet Git sideways: a plugin wants a repo, a colleague says “just clone it,” GitHub throws a wall of green squares at you. So it reads as developer furniture. It isn’t. It is the single most durable answer to the question that quietly wrecks building archives.

The Tool: Git is a distributed version-control system — every clone is a full copy of the whole history, not a checkout from a server you have to trust. That’s the word that matters: distributed. The project lives on git-scm.com, it’s the reference implementation Torvalds started and Hamano stewards, and it costs a computational designer exactly one afternoon to stop fearing. Worth the afternoon because it turns “final_v7_REALLY_final.ifc” into a history you can actually read.

Here is the part my desk cares about. The buildings that aged badly weren’t the ugly ones — they were the ones nobody could reopen, because a proprietary format went dark and took the source with it. Git is the opposite bet: plain text, human-readable diffs, no vendor who can revoke your ability to open your own work. When the company disappears, the repository is still sitting on your disk, complete.

←TODAY: In 2026 you can install Git in ten seconds and keep a full project history offline, forever, for free. →3012: In the Zurich-3012 archive, the files that survived were the ones a stranger could still open without a licence server. Fulcrum: A tool you can run offline forever is the only one whose files you truly own.

The distributed design also carries a cost, and it’s fair to name it plainly: because every clone is a full peer, the platforms wrapped around Git — GitLab, GitHub, the forges — become fat targets. GitLab patched a flaw on 10 June; six weeks later, on 24 July, researchers at depthfirst published working exploit code, as The Hacker News reported. On any un-updated self-managed 18.11.3 server, an authenticated user who could push to a project commits a crafted Jupyter notebook, opens its commit diff to leak a heap pointer, and — per Cyber Security News, chaining two memory-safety flaws in the Oj Ruby JSON parser — runs commands as git. None of that is Git-the-format’s fault; it’s the server layer, and the fix is unglamorous — update the box. The deeper lesson sits in the purplesyringa essay PAZ filed on supply-chain trust: the Rust Foundation employed just four software engineers in 2024, and no registry owes you safety. The safe, quiet copy is the one on your laptop, not the one behind someone’s web login.

Setup:

git --version                       # want 2.x; if missing:
                                    #   winget install Git.Git   (Windows)
                                    #   brew install git         (macOS)
                                    #   apt install git          (Debian/Ubuntu)
mkdir wettbewerb-2026 && cd wettbewerb-2026
git init                            # this folder is now a repo
echo "roof-v1.ifc  handstair  origami-leaf" > README.md
git add .
git commit -m "First submission snapshot"
git log --oneline                   # proof: one commit, your name on it

First steps:

1. Point Git at a real project folder — your exported IFCs, your .gh scripts, your detail SVGs — and run git init there. Nothing moves; a hidden .git folder just starts watching.
2. Add a two-line .gitignore holding *.bak and *.tmp so Rhino and Archicad scratch files stay out of history.
3. Every time a drawing set reaches a milestone, run git add -A && git commit -m "Vorabzug BG, rev C". You now have a timestamped, named checkpoint you can return to.
4. Run git log --oneline and read your own project’s spine. That list is the thing you wished you had the last time someone asked “which version did we send the Bauleitung?”

Atelier: For a Swiss studio, the reach-for-it moment is the Wettbewerb deadline and the coordination round after it — the week where three people edit the same model and “final” stops meaning anything. Git gives the Büro one shared, honest history instead of a shared drive full of dated copies nobody trusts. Your Monday move: pick the current live project, cd into its folder, run git init, and make your first commit before lunch — one repo, one habit, no server, no subscription.

Hack: See exactly which detail sheet moved between two submissions, without hunting through folders. Git tracks history per file, so you can ask it about one plan alone and read the change instead of guessing. Do this after two commits:

git add plan-EG.svg && git commit -m "EG rev C"
git log --oneline -- plan-EG.svg    # every revision of just this file
git diff HEAD~1 -- plan-EG.svg      # what changed since the last rev

Because SVG, IFC, JSON and .gh-adjacent exports are text under the hood, git diff shows real line-level changes — a moved door, a renamed layer, a shifted coordinate — not a black-box “file changed 14:32.” That is the whole trick: keep the load-bearing stuff in formats Git can read, and every edit becomes reviewable.

PAZ has leaned on exactly this discipline before — the open IFC toolkit IfcOpenShell lives and ships on Git, which is why a 2015 script from it still clones and runs today. That’s not luck; it’s the format choice. Git’s user interface is famously friendly, if you already know Git — but you don’t lose an afternoon to a dialog box that ate your work, because there is no dialog box, just your files and their history.

Start today with one repo. Not a migration, not a policy PDF, not a workshop — one folder, git init, one commit. In twenty years that’s the difference between a project you can reopen and a project you can only remember.

Learn-it:

• Home & docs: git-scm.com — the reference implementation, downloads, and the free reference manual.
• Why the update matters: The Hacker News on the depthfirst GitLab RCE PoC — the server layer, not the format, is the soft target.
• The flaw’s mechanism: Cyber Security News on the Oj JSON-parser memory-safety chain.
• Git in AEC practice: IfcOpenShell — an open IFC toolkit that survives because it ships on Git.
• PAZ context: PAZ webinar — GIS-to-BIM workflows & automation, where version-controlled data is the quiet backbone.