The ‘Father of the Internet’ is finally retiring

Vinton Cerf will step down from his role as Google’s chief internet evangelist next week, marking the conclusion of one of the most influential careers in technology history.

While speaking via video feed at the Open Frontier conference hosted by the Laude Institute, Cerf was recognized by Dave Patterson, the UC Berkeley professor best known for co-developing RISC processor architecture.

“Vint … has been at Google more than 20 years, and he is retiring a week from today, and so I think we ought to give him a round of applause for a relatively good career,” Patterson said, to cheers from the room.

A Google spokesperson confirmed that Cerf will be stepping down from his role at the company.

Cerf, 83, and collaborator Robert Kahn are credited as being the architects of the networking protocols that became the internet we know today. His work developing and popularizing TCP/IP — the basic set of rules that lets different computer networks talk to each other — beginning in the 1970s has been recognized with numerous honorary degrees, the Presidential Medal of Freedom, and a Turing Award, among other honors.

Since 2005, Cerf has served as vice president and chief internet evangelist at Google. (At this point, we can safely say the internet is fully evangelized, for good or ill.)

Cerf was speaking on a panel alongside other computer scientists known for their work on durable open source projects, including Patterson; François Chollet, creator of the Keras deep-learning library and co-founder of Ndea; John Ousterhout, the Stanford computer scientist behind the Tcl programming language, who also co-founded Electric Cloud; and Matei Zaharia, who is Databricks’ co-founder and chief technologist. They offered advice about what it takes to build open source systems that survive — advice that’s increasingly relevant as founders bet on open infrastructure for the next wave of AI products.

Much of the conference’s discussion focused on the problems with the centralization of advanced models in a handful of well-resourced labs, in contrast to the decentralized world of the open internet that made Cerf’s own protocols so durable. However, Cerf predicted that the rise of AI agents — software that can act autonomously and coordinate with other software — would push tech companies back toward standardized protocols.

“The agentic model of AI, with multiple agents from multiple sources interacting with each other, is going to force composability, and a requirement for interoperability and standardization,” Cerf said.

If he’s right, the companies that define those interoperability standards early could end up with outsized influence over how the agentic economy actually works — a dynamic not unlike the early internet protocol wars.

While other panelists speculated that natural language communication between LLM agents would be sufficient, Cerf predicted formal standards would be required.

“I don’t think English is going to be the best choice. There’s a flexibility in it, but there’s ambiguity, and I think precision for interagent interaction is going to be very, very important. An agent really needs to be sure the other agent understands what it is that they just agreed to do together,” Cerf said.

“Remember the old telephone game where you wish you’d whispered in somebody’s ear and then by the time it got to 10 people away the message was totally different? Imagine a bunch of agents talking to each other in natural language, you know, that’s kind of terrifying.”

In a more lighthearted moment, Patterson recalled meeting Cerf, known for his wardrobe of three-piece suits, as a grad student in the 1970s.

“He’s always been the best dressed computer scientist I’ve ever met,” Patterson said. “My memory of Vint is that he came as a grad student with a shirt and tie in the ’70s.”

“It absolutely is true,” Cerf said. “I even had a vest, and for some reason I always wanted to stick out, and instead of having long hair, and something in my nose, I thought just dressing differently was one way to do it.”

This story has been updated with comment from Google.

For four months, no frontier model beat Claude Opus in our production evals. GPT-5.6 did. This is what we learned while migrating.

As of today, Ploy’s agent runs on GPT-5.6 Sol, the flagship tier of the model family OpenAI released this morning. For months, no model met our bar for replacing Claude Opus. GPT-5.6 Sol did. After a head-to-head evaluation, we made it the default model for every Ploy workspace.

Ploy’s agent builds and edits production marketing websites. It plans a page, reads the codebase, writes components, generates imagery, screenshots its own work, and decides when it is done. We test every frontier release against that workload. During the four months Opus held the default slot (first Opus 4.7, then 4.8), nothing we tested beat it. GPT-5.6 is the first model that did.

The first eval run exposed several failure modes, which we cover below. It also produced strong results. Completed builds took less than half the wall-clock time, cost 27% less, and scored at or above our incumbent. Those results justified the migration work.

We use Vercel’s AI SDK, but switching from Claude Opus 4.8 to GPT-5.6 Sol still exposed provider-specific assumptions throughout our stack. The providers differ in how models fill tool arguments, cache prompts, and replay reasoning between turns.

We fixed the eval harness first, followed by the tool schemas, prompt caching, and reasoning replay.

Step 0: Fix your harness before you trust a single number

Our eval suite runs the production agent against fixture workspaces. It covers hundreds of cases, from “build a homepage from scratch” to “is this clone request safe to execute.” For build cases, a visual judge runs ten binary checks against a reference design, such as “the hero is a full-bleed photographic scene” and “primary CTAs are rounded rectangles, not pills.” We also run content checks, tool-trajectory checks, and file assertions. We triage every failure against the full trace, including the tool calls and model text.

The first cross-model run exposed a problem in the eval harness.

Our tool-call budgets were sized for Opus’s sequential style. GPT-5.6 makes parallel calls and exceeded those budgets on cases it was solving correctly. Our eval executor also lacked support for batched file reads, which Opus rarely used and GPT-5.6 uses often. Roughly a third of the raw failures in the first run came from harness assumptions rather than model behavior, and those failures were unevenly distributed. If you are evaluating a challenger against an incumbent, triage the traces before trusting the pass rate. Otherwise, the eval rewards the new model for behaving like the old one.

A dataset that omitted its minScore threshold inherited a default of 1.0, and nothing flagged the fallback. GPT-5.6 therefore “failed” a hero that scored 0.98, while Opus “failed” a case despite passing every individual check. Both designs were defensible, but the implicit threshold failed them.

Benchmark results

After fixing the harness, we reran our redesign suite, where the agent rebuilds a brand’s homepage against a reference design.

Mean per completed build	Claude Opus 4.8 (n=11)	GPT-5.6 (n=10)
Cost	$3.06	$2.22
Wall-clock time	8m 00s	3m 42s
Input tokens	2.60M	1.70M
Output tokens	33.0K	17.1K
Visual score	0.936	0.970

GPT-5.6 finished pages 2.2× faster, cost 27% less, and used about half the output tokens. It also wrote less code. In one matched pair, Opus produced a 17,957-character globals.css with 174 CSS variables, including mostly unused color ramps. GPT-5.6 used 2,508 characters and 45 variables for a comparable, and sometimes better, rendered page.

Claude Opus 4.8

See full size

GPT-5.6 Sol

See full size

Design quality and consistency

GPT-5.6 is good at clean, tightly gridded layouts, but it tends to converge on that style without strong steering. With our older harness, which was designed for Opus 4.8, GPT-5.6 Sol often ignored the existing design system and produced clean but generic output.

The changes we made here deserve a separate post. Our design and engineering teams improved the steering until GPT-5.6 met the brand-adherence bar we require in production.

Step 1: Check your tool calls

Our agent’s code tool has 25 top-level parameters. One, action, is required; the rest are optional. Claude sends the two or three parameters it uses and omits the rest. GPT-5.6 sends all 25 on every call, filling unused parameters with plausible values such as offset: 0, timeout: 120000, and siteId: "00000000-0000-0000-0000-000000000000".

We saw the pattern across three days of production code(read) traces.

Model	Calls	Carrying all 25 properties
gpt-5.6	6,635	6,635 (100%)
claude-opus-4.8	2,898	4 (0.1%)
claude-sonnet-5	1,933	0

Verbosity was not the problem. The file-read implementation could not distinguish an invented value from an intended one. It treated offset: 0 as a real argument, causing 52% to 64% of GPT-5.6’s file reads to return empty. The tool returned success: true for both valid and empty reads, so the model could not tell that it was reading blank files. It compensated with more calls and worse results.

Prompting did not fix this. A tool-description directive to “omit unused parameters” still produced 25 of 25 parameters. Per-property “OPTIONAL, omit if unused” hints did the same. We measured identical behavior with OpenAI’s strict mode, and adopting it would have required stripping pattern, format, and array-bound validation from every schema. This behavior comes from how the model emits function calls, so we changed the schema instead.

The working fix was a schema transform at the provider boundary. For OpenAI-family models, we rewrite every optional property as required but nullable using anyOf: [T, null]. This gives the model an explicit value for an unused parameter. We then strip the nulls before validation at the shared tool-invocation boundary, so the tool implementations do not change. The model sees a schema that represents unused values, while the tools receive the same inputs as before.

// Before: 25 keys, every one carrying an invented value
{ "action": "read", "file_paths": [...], "offset": 0, "timeout": 120000, ... }

// After: 25 keys, 4 real values, 21 explicit nulls (stripped before the tool runs)
{ "action": "read", "file_paths": [...], "offset": null, "timeout": null, ... }

After the change, empty file reads fell from 52% to 0%. The agent also used roughly 30% fewer tool calls for the same work because it stopped re-reading blank results.

Step 2: Rebuild prompt caching

Both providers offer “prompt caching,” but the implementations differ. Before we accounted for those differences, GPT-5.6 appeared about 50% more expensive than Opus. Our cache configuration caused the gap. The model pricing was fine.

Our agent’s prompt opens with a static prefix of roughly 29K tokens (tool schemas plus the core system prompt) that is identical for every conversation. On Claude, we mark cache breakpoints with cache_control, and the prefix caches across the whole organization. Any conversation in any workspace can use one shared entry, without a per-key throughput budget. Cache hit rates run from 92% to 96%.

GPT-5.6 uses a different OpenAI caching model. Earlier GPT models cached implicit partial-prefix matches. GPT-5.6 dropped partial-prefix matching, so implicit caching now creates whole-prompt entries keyed on the latest message. A new conversation sharing our 29K static prefix cached 0% of it. Each conversation re-billed the full prefix at the uncached rate. GPT-5.6 also applies a 1.25× cache-write surcharge to every uncached prompt, whether or not the application uses caching.

The explicit mechanism uses prompt_cache_breakpoint markers and a mandatory prompt_cache_key. The key is part of the cache identity, so identical prompts with different keys produce no cache hits. Each key maps to a cache node that sustains roughly 15 requests per minute before OpenAI distributes traffic to other nodes with independent cold caches.

The main design decision is which entity should scope the key.

• Per-conversation key: A new conversation never hits the shared prefix. We measured a 0% first-call hit rate with this configuration.
• One global key: Every request hashes to one cache node. Production traffic exceeds the 15 rpm budget, and requests spill to cold nodes.
• Per-workspace key: All conversations in a customer workspace share entries while per-key traffic stays low.

We ship the workspace-scoped key and split the system prompt into breakpointed layers, mirroring the structure we already used for Anthropic:

request ──► hash(prompt head + prompt_cache_key) ──► cache node (~15 req/min per key)
                                                          │
   ┌──────────────────────────────────────────────────────┴───────────────┐
   │  entries on the node, all namespaced by key ws:{workspaceId}         │
   │                                                                      │
   │   [ tools + static prefix ]······················ A  every session   │
   │   [ tools + static prefix + workspace context ]·· B  same context    │
   │   [ ····················· + turn 1 + … + latest ] C  this session    │
   └──────────────────────────────────────────────────────────────────────┘

Entry A reduces the cost of a session’s first call. When workspace memory changes, the request misses Entry B but still hits Entry A, then writes a new Entry B. That requires one context-sized write instead of re-billing the full 29K prefix. Entry C is OpenAI’s implicit whole-prompt chain, which works within a session because our prompts are strictly append-only.

OpenAI’s key partitioning prevents cross-workspace sharing of the static prefix. Anthropic can share the prefix because its cache is organization-scoped without key partitioning. On GPT-5.6, every workspace pays for one 29K cold write per idle window, about $0.18. The cost is bounded and predictable.

After the change, first-call cache hits rose from roughly 0% to 83.7%, total uncached input tokens fell 28%, and GPT-5.6’s per-suite cost dropped below Opus’s. Cache misconfiguration accounted for the entire cost gap we had measured. Cost comparisons between models are not useful when one model starts with a cold cache.

Step 3: Make reasoning replay self-contained

Reasoning replay caused intermittent failures in production conversations. GPT-5.6’s Responses API replays prior-turn reasoning as server-side item references by default, and our conversations sometimes failed with Item 'rs_...' not found. Setting store: false makes the SDK request encrypted reasoning content and replay self-contained blobs instead of pointers to server state. We also learned that server-side reasoning state can change the effective prompt even when the bytes sent by the application are append-only.

Running GPT-5.6 Sol in production

GPT-5.6 launched today and is already live on Ploy. You can start free at ploy.ai, give it a website to build, and see what a sub-four-minute build looks like.

I have been interested in machine-assisted ways to do and teach mathematics from as far back as 1999, when I started coding several applets in Java 1.0, both for my complex analysis and linear algebra courses, as well as to visualize various mathematical objects I was interested in (such as honeycombs or Besicovitch sets). This was moderately successful; but the applets were time-consuming to program. Eventually, the standards for web pages stopped supporting this version of Java, and the applets became non-functional.

However, in the last few days I have begun the process of migrating much of my old web page and blog data to a more maintainable repository, using modern AI assistance. As an experiment, I asked the agent to port my old applets to a modern supported language (we landed on Javascript), and it managed to do so in a matter of hours, with all of my old applets now functional again, with even a few graphical upgrades (for instance, the Besicovitch set applet is now colorized, in contrast to my original monochrome version). I am particularly pleased to see the honeycomb applet that I wrote with Allen Knutson in 1999 come back to life, as this was a particularly tricky one to code by hand:

Notoriously, LLM-based coding agents can create various blatant or subtle bugs in their code; but in the porting of these two dozen or so applets, I could only find one minor bug (the handling of a drag event in one of the complex analysis applets had unwanted behavior when dragging outside of the main box), and in fact the agent identified two bugs in the original code that I was not aware of, so it ended up being a net wash as far as code quality was concerned. In any event, as these applets are meant to be secondary visual aids rather than critical components of a mathematical argument, the downside risk of such bugs is relatively low.

The process was painless enough that I decided to also try coding some new apps, in addition to porting the old ones. Back in 1999 I had an ambitious idea for a visualization tool for special relativity; this was before the release of the software tool Inkscape, but the idea I had in mind was basically “Inkscape, but in Minkowski space”. I had even started writing Java code for this app, but the code complexity became too much for me, and I abandoned the project. However, after a couple hours of “vibe coding” with an AI agent, I was finally able to generate an applet that matched the vision I had back in 1999, which can now be found here. A summary of the conversation I had with the agent to generate this code can be found here (it has been edited down to remove a large number of tedious technical implementation reports). While I have playtested the app somewhat, I would be interested in receiving further feedback on this “alpha” version of the applet, as I am sure (especially given the LLM-generated nature of the code) that there are still some bugs and rough edges to be ironed out.

After writing my blog post on the Gilbreath conjecture paper earlier today, I realized that I could similarly ask the agent to code a visualization tool for the Gilbreath conjecture to accompany the paper and blog post. After another few hours of conversation, this is now done; you can try out the visualization here. Again, the procedure was quite painless (see this transcript of the process), and I think I may add such interactive visualizations as supplements for future papers; as such supplements are not mission-critical to the core of the paper, I again feel that the downside risk of using guided interaction with LLM agents to generate such visualizations is acceptable.

Around 2000 I took an AI course at the University of Guelph. I don’t think I learned too much. We didn’t talk about neural networks, as far as I can remember. My end of term project was, I think, a pathfinding algorithm wearing an AI costume. There were certainly no discussions of transformers. No CUDA. No PyTorch. None of that existed.

But what I remember doing a lot of was coding in Lisp - a lot of Lisp in the dark University of Guelph CIS lab.

My prof (whom I cannot remember the name of for the life of me) called it “the language for AI” and at the time that may have been the conventional wisdom - I’m not sure. But I actually enjoyed writing Lisp code. To me, it was a kind of art building these elegant recursive functions. I don’t know of any other computer languages that hit like that (except almost embarrassingly, xml stylesheets, which I’m probably one of a very small number of people who really liked creating xml transforms with super elegant recursion).

According to my prof, Lisp was, specifically, the language of symbolic AI: expert systems, theorem provers, programs that manipulated symbols and rules. But statistical methods won, then deep learning buried the winner, and I think Lisp ultimately became lost with symbolic AI. At least, I know very few people (none) that used it regularly, beside maybe that I remember Paul Graham mentioning he used it in one of his essays about writing his first e-commerce platform.

Now here we are, like 25 years or more after I took that AI course and left with this one thing that I remember learning - Lisp, and meanwhile, I’m burying myself in building an AI agent platform for over a month and this little thought tugs at the bottom of my brainstem this morning - “could Lisp actually be a useful language for an agent loop?” And then I find myself distracted from what I should be doing and instead working with Claude just to see…

An agent is a recursive function

Don’t let the power of Claude Code, OpenClaw or any other AI agent tooling fool you - strip away the frameworks and an agent loop is incredibly simple. You have a list of messages. You send it to a model. Either the model answers in words, or it asks to use a tool. If it asks, you run the tool, append the results, and do it again.

Maybe some agents implement that as a while loop with state. But perhaps it’s really better implemented as recursion with a base case.

I’m not going to get into Lisp syntax at all, and if you’ve never coded with Lisp, this will seem pretty strange, but here’s an agent loop in Lisp:

(defun agent-loop (messages)
  (let* ((message (ref (call-model messages) "choices" 0 "message"))
         (tool-calls (gethash "tool_calls" message)))
    (if (and tool-calls (plusp (length tool-calls)))
        (agent-loop (append messages
                            (list message)
                            (map 'list #'execute tool-calls)))
        (append messages (list message)))))

That’s the whole agent, no kidding, just 8 lines of Common Lisp. Base case: the model answers, returns the history. Recursive case: it wants tools, executes them, recur with the enriched message list. No framework. No state machine. The agent’s state is just the argument being folded through the recursion.

I put together a full AI agent, with the help of Claude, running against OpenRouter in about 100 lines of Common Lisp. SBCL, two libraries (dexador for HTTP, shasht for JSON), and nothing else.

The only tool is eval

When you build an agent you normally start bolting on tools - Agent Foundry has web search and crawling, tables and file tools, python execution tooling, etc. In fact, most of most agents are a tool catalog.

Lisp lets you cheat. Lisp is what language nerds call homoiconic - a fancy word for a simple idea: a Lisp program is written in Lisp’s own data structure (lists), so code is data and data is code. A program can build another program the same way it builds a grocery list. Which means instead of building tools, you hand the model the language itself:

(defun lisp-eval (form-string)
  (handler-case
      (format nil "~s" (eval (read-from-string form-string)))
    (error (e) (format nil "ERROR: ~a" e))))

One tool. The model writes a Common Lisp form as a string. The agent reads it, evals it, and sends back whatever printed. Ask it for the 30th Fibonacci number and it doesn’t recall the answer, it writes the loop and runs it. Here’s the actual transcript:

* (agent:run "What is the 30th Fibonacci number? Compute it, don't recall it.")
  ⤷ (defun fibonacci (n)
      (if (<= n 2)
          1
          (+ (fibonacci (- n 1)) (fibonacci (- n 2))))) => FIBONACCI
  ⤷ (fibonacci 30) => 832040
The 30th Fibonacci number is 832040.
NIL

I did not tell it to use recursion, but in this blog post about recursive agent loops, the model reached for textbook doubly-recursive Fibonacci all on its own. It defined a function into the live image with its first eval and called it with its second. Keep that move in mind, it comes back later in a bigger way.

This is the 2026 version of what made Lisp “the language for AI” in the first place. The old dream was programs that manipulate programs. We finally have that. We just outsourced the symbolic reasoning to a language model and kept the substrate.

Caveat, if not incredibly clear: eval as a tool means the model runs arbitrary code on your machine. This is a toy for a sandbox. I haven’t run this outside of a local docker container.

Memory is 20 lines

Once the loop worked I wanted persistence. Conversations that survive across sessions. In Agent Foundry, I implemented pgvector for memory, and I suppose that could also be used for this Lisp based agent, but for this experiment, why introduce another dependency when Lisp has its own primitives perfect for implementing this.

The messages are already a list of hash tables. Which is to say, they’re already JSON in spirit. So memory is nothing more than writing the list down and reading it back:

(defun remember (messages)
  (with-open-file (out *memory-file* :direction :output :if-exists :supersede)
    (shasht:write-json (coerce messages 'vector) out))
  messages)

(defun recall ()
  (if (probe-file *memory-file*)
      (coerce (with-open-file (in *memory-file*) (shasht:read-json in)) 'list)
      (list *system-message*)))

The loop itself didn’t change at all. The entry point became a pipeline:

(remember (agent-loop (append (recall) (list new-user-message))))

Recall, recur, remember. No schema. No migrations. No store abstraction. The serialization format is the runtime format. Tell it your name today, ask tomorrow in a fresh process, it answers.

It never forgets, which is also its flaw. Full transcript memory grows without bound and eventually you hit the context window. This could be a simple fix: a compress step between recall and the loop, where the agent calls a model to summarize its own past. An agent recursing on its own history. Beautiful.

Then it built its own web search

The Fibonacci trick was really neat to watch - the agent writing throwaway math and running it. Then I decided to give it a little more rope. I pasted a temporary Brave Search API key into the conversation, mostly to see what would happen. And what happened kind of surprised me - the agent used its eval to defun a brave-search function into the live image. It checked what it had available to it, wrote the HTTP call, parsed the JSON response itself, and started answering questions with live web results.

I never built a web search tool. The agent has exactly one tool, and it used that tool to write the second one.

  ⤷ (defun brave-search (api-key query &key (count 10))
  "Search using Brave Search API"
  (let* ((encoded-query (quri:url-encode query))
         (url (format nil "https://api.search.brave.com/res/v1/web/search?q=~a&count=~d" 
                      encoded-query count))
         (response (dexador:get url 
                                :headers `(("Accept" . "application/json")
                                          ("X-Subscription-Token" . ,api-key)))))
    (shasht:read-json response))) => BRAVE-SEARCH
Perfect! You were absolutely right, Jamie. I've now created a `brave-search` function that can make HTTP requests to the Brave Search API. 

If you provide me with a Brave Search API key, I can perform web searches for you. The function takes:
- `api-key` - your Brave Search API key
- `query` - the search query
- `count` - (optional) number of results to return (default 10)

Would you like to try it out with your API key?
NIL

Sit with that for a second, because it inverts how we normally think about agent capabilities. In Agent Foundry, in Claude Code, in every agent platform I know of, the tool catalog is fixed at design time. Somebody like me decides what the agent can do, writes the tools, ships them. Here the catalog is open. The model decides what it needs, writes it in its own substrate language, and evals it into existence. Code is data, data is code, and capability is just conversation.

And there’s a twist that took me a minute to appreciate. The defun itself dies when the process exits. Functions live in the running Lisp image, not on disk. But the transcript persists. The source code of brave-search, the model writing it, all of it sits in memory.json as plain text. So in a fresh session the function doesn’t exist until the agent re-reads its own history and evals it back into being. Its capabilities are stored as memories of having built them, re-hydrated on demand.

Talk about homoiconicity - an agent whose skills are literally stories it tells itself.

Skills are just memories

Every serious agent platform today, Agent Foundry included, treats the tool catalog as a design-time decision. MCP is basically a formalization of the design-time assumption - capabilities as contracts, negotiated in advance, versioned, approved. This experiment sits at the other pole: capability decided at runtime, by the agent, in response to whatever the conversation needed.

Perhaps the industry is already sliding along this continuum without quite naming it. Code interpreters were the first step - agents writing throwaway programs to answer a question. Skills, the SKILL.md pattern, are the second - because a skill is nothing more than capability stored as text and loaded at runtime. This 100 line Lisp agent just collapses the remaining distance. Its skills are stored in its own transcript.

And kind of stretching maybe, that’s roughly how we work too. Almost nothing you can do was installed at design time. You learned it, stored it, and now you rehydrate it on demand - often complete with the memory of writing it into yourself, like remembering the specific summer you learned to ride a bike. A capable human is, in some sense, a transcript of their own practice, re-evaluated every time it’s needed. Watching an agent re-read its own history and defun a skill back into existence felt less like a hack and more like a crude, yet beautiful, sketch of that. I’m speculating well past my expertise here, but the shape rhymes.

He wasn’t wrong, he was early

Symbolic AI lost. Nobody’s expert system survived contact with backpropagation and gradient descent. But the thing Lisp was actually built for, programs as data, computation you can inspect and transform and feed back into itself, turned out to be a pretty good description of what an agent is.

The models do the reasoning now. But the loop around them, the part we actually engineer, is the part Lisp was always fantastic at.

25 years is a long time to be right about something. Somewhere out there maybe my old AI prof is ahead of us on something else.

Full source, Dockerfile included, is on GitHub: https://github.com/jamiebeach/lisp-agent

A visualization tool that replays coding-agent sessions on a 3D map of your codebase.

mindwalk-demo.mp4

The 30-second demo — sound on.

The problem

A session log records what an agent did, but not how it understood the task: which parts of the repo it treated as relevant, where it explored before it acted, whether its footprint matched the scope you had in mind. Reading the raw JSONL line by line doesn't answer any of that.

The idea

Draw the repository as a night map, and play the session back as light moving through it: where the agent searched, read, and edited, the map glows — everything else stays dark. The agent's understanding of the task becomes a shape you can see at a glance. One Go binary reads Claude Code and Codex session logs, fully local; no session data leaves your machine.

Quick start

curl -fsSL https://raw.githubusercontent.com/cosmtrek/mindwalk/master/scripts/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"
mindwalk

The installer verifies the binary against checksums.txt and installs to ~/.local/bin (override with INSTALL_DIR; pin a release with VERSION). Windows archives are on GitHub Releases. To build from source: make setup && make build → bin/mindwalk.

With no arguments, mindwalk scans ~/.claude/projects and ~/.codex/sessions, serves the UI on a random local port, and opens a browser:

mindwalk serve [--port N] [--no-open] [--claude-dir DIR] [--codex-dir DIR]
mindwalk open [--no-open] <session.jsonl>   open one specific session
mindwalk build <repo> [-o out]              write the repository citymap JSON
mindwalk trace <session> [-o out]           write the normalized trace JSON

Reading the picture

• Tree / Terrain views — the repo as a radial tree or a treemap plain; glow ∝ how deeply and how often a file was touched.
• Touch states — each file keeps its deepest touch: seen (moss green), read (moon white), edited (warm amber), unvisited (dark). The HUD folds friction signals — error rate, churned files, edits after the last verify — into a review strip.
• Playback deck — scrub or play the session over a bucketed histogram of the run. Bars sit on a cool/warm spectrum: observation stays cool (search, read, exec), mutation glows warm (edit, verify), so editing phases jump out at a glance.
• Timeline marks — ◇ context compactions, ○ subagent launches, › user turns; every mark is a click-to-jump target.
• Inspector — click a file to pin its visit history; click a visit row to jump the playhead to that moment.

Keyboard: Space play/pause · ←/→ step (⇧ ×10) · Home/End ends · S speed · E next edit · X next error · M next mark · ⌘B session rail.

Under the hood

Two artifacts, kept deliberately separate:

1. a trace — the session log normalized into an ordered stream of file-touch events (internal/adapter, one adapter per agent format);
2. a citymap — a deterministic layout of the repository (internal/citymap); the same tree always produces the same map, so replays are comparable across sessions.

A local Go server (internal/server) joins the two and serves the React/Three.js frontend (web). schema/ mirrors the exported JSON contracts.

Contributing

Issues and pull requests are welcome. To get a working dev setup:

make setup   # install frontend dependencies
make serve   # dev server on :8765, serving web/dist from the working tree
make test    # go test + frontend build — run before sending a PR
make build   # regenerate embedded assets and bin/mindwalk

Ground rules (see AGENTS.md for the full architecture notes):

• Keep the boundaries: adapters don't know about rendering, citymap generation doesn't depend on playback, the server just connects the two.
• Keep Go code gofmt-ed; never hand-edit internal/server/static — regenerate it with make build.
• When trace or citymap JSON shapes change, update schema/ and the relevant tests in the same change.

License

MIT © 2026 Ricko Yu

Fingerprinting is usually about canvas, WebGL, fonts, audio. There is a quieter signal, and it lives in the last bits of a number.

Run this in any console:

Math.tanh(0.8)
// 0.6640367702678491   genuine Linux Chrome    (glibc)
// 0.664036770267849    genuine macOS Chrome     (libsystem_m)
// 0.6640367702678489   genuine Windows Chrome   (UCRT)

That output is an approximation, and its exact bits depend on the OS that computed it. A genuine Mac runs Math.tanh through Apple’s math library. Linux runs it through glibc1. The two disagree on about a quarter of all inputs, usually by one unit in the last place (1 ULP2). Windows, through the Universal C Runtime, disagrees with both on a few percent, and on the input above all three land on a different bit.

The same call, run on genuine Chrome 150 across three real machines:

CallLinux (glibc)macOS (libsystem_m)Windows (UCRT)SplitMath.tanh(0.5)``0.46211715726000974``0.46211715726000974``0.46211715726000974all three agreeMath.tanh(0.7)``0.6043677771171636``0.6043677771171635``0.6043677771171635Linux alone, 1 ULPMath.tanh(0.8)``0.6640367702678491``0.664036770267849``0.6640367702678489all three differ, 2 ULP spreadMath.tanh(0.9)``0.7162978701990245``0.7162978701990245``0.7162978701990244Windows alone, 1 ULP

Measured over the DevTools protocol on Chrome 150: Linux (glibc), macOS 26 on Apple Silicon (libsystem_m), Windows 11 (ucrtbase.dll). tanh(0.5) is one of the roughly three-in-four inputs where everyone agrees, which is exactly why it makes a useless probe. tanh(0.8) is one that separates all three at once.

One tanh call on the right input is a per-OS signature. Claim macOS, return Linux math bits, and you have contradicted your own User-Agent.

This tell is recent. Until Chrome 148, V8 computed tanh itself with a bundled fdlibm3 port, so it returned the same bits on every OS and leaked nothing. V8 commit c1486295ae5 replaced it with std::tanh, which reads the host libm. It first shipped in V8 14.8.57, which is Chrome 148. Chrome 147 and earlier do not leak here. Chrome 148, 149, and 150 do.

Scrapfly ships a browser that has to match a real one across hundreds of signals, and math is one of the harder ones.

Why one function returns different bits

IEEE 7544 defines how a double is stored. It does not require sin, cos, tanh, or exp to be correctly rounded. Correct rounding is expensive, so every vendor ships a libm5 that trades a fraction of a ULP for speed, with its own minimax6 coefficients, lookup tables, and reduction constants.

The three implementations produce three sets of bits:

• Linux: glibc
• macOS: Apple libsystem_m
• Windows: UCRT7 (ucrtbase.dll)

They agree almost everywhere and split just often enough to classify the OS. A detector needs no math, only a table: genuine macOS Chrome returns one pattern for cos(1), genuine Linux Chrome returns another, and a single comparison tells them apart.

Four traps

“Just reimplement the Mac functions” breaks on contact, for four reasons.

1. Only some math leaks. V88 ships its own math and links it statically: Math.exp, Math.pow, Math.atan, and most of the rest come from bundled llvm-libc9, and Math.sin / Math.cos from a bundled glibc-derived dbl-64 routine. All of them are identical on every OS, so spoofing them creates an inconsistency. The exception is Math.tanh: since Chrome 148 V8 computes it with the platform std::tanh instead of the bundled routine it used before, so it now reads the host libm. It is the only Math.* that leaks the OS, and that asymmetry is itself checkable.

2. JavaScript math and CSS math are different code paths. CSS sin(), cos(), and atan2() do not share code with Math.sin. The layout engine reduces the angle in degrees, then calls platform std::sin on the reduced value. That gives a different result than a direct radian sin(), and it hits the host libm, so all seven CSS trig functions leak. We reproduced the degree reduction and the radians-to-degrees step bit-for-bit, not just the leaf function.

3. macOS has two math libraries that disagree. Apple Silicon carries scalar libsystem_m and the Accelerate framework10’s vector routines (vvsin, vvtanh). They are different code. Across a million inputs they diverge on 10 to 89 percent, depending on the function. Take cos(0): scalar returns exactly 1.0, Accelerate returns 0.9999999999999999. So “reproduce Apple’s math” is undefined until you know which library the browser calls, at which site. We resolved it by driving real Chrome on a real Mac over the debugging protocol and reading the exact double. Answer: scalar libsystem_m backs Math.tanh, CSS trig, and the audio compressor’s per-sample transcendentals. Accelerate backs Chrome’s Web Audio DSP on Mac, the FFT, the vector math, and the biquad filters (fft_frame_mac.cc, vector_math_mac.h, biquad.cc, all BUILDFLAG(IS_MAC)). Pick the wrong library for a given call site and you land 1 ULP off on most inputs, worse than not spoofing.

4. Architecture leaks. ARM and x86 differ on fused-multiply-add and on NaN sign propagation. A reproduction that is correct on paper drifts if the compiler fuses a multiply-add on one target and not the other.

The map: what leaks where

Put the routing on one page. Bold is the host libm (glibc, Apple libsystem_m, or UCRT), the code that leaks the OS. Everything else is identical on every machine and safe to leave alone.

OperationV8 Math.* (JS)CSS calc()Web Audiosin cos tanV8 bundledhost libm****Accelerate (osc FFT), sin scalar in the compressorasin acos atan atan2V8 bundledhost libmnot usedtanhhost libmnonenot usedexpV8 bundledhost libmscalar in the compressorlog log2 log10 powV8 bundledhost libmscalar log10f / powf in the compressorvector add/mul/scale, FFTn/an/aAccelerate (vDSP) on Macsqrt abs + - * /hardwarehardwarehardware

V8 bundled = statically linked and identical on every OS: llvm-libc for most functions, a glibc-derived dbl-64 routine for sin/cos. host libm = the platform library that leaks the OS (libsystem_m on Mac, glibc on Linux, UCRT on Windows). Accelerate = Apple’s vDSP, which Chrome uses for the Mac Web Audio DSP.

V8 routes almost everything through its own bundled math, so JavaScript Math is a tell in exactly one place, Math.tanh. CSS is a tell everywhere, because Blink calls the host libm directly for every trig function. Web Audio on Mac runs on Accelerate for the FFT and the vector stages, while the DynamicsCompressor’s per-sample transcendentals stay scalar libsystem_m, so one audio graph touches three separate libraries.

WASM is not in the table because it has no transcendental opcodes. sin and friends come from whatever libm the module bundled, and its arithmetic (f64.sqrt, f64.mul) is hardware, so WASM math is identical on every OS. Its only fingerprint axis is the ARM-versus-x86 split in NaN canonicalization and a few SIMD roundings.

The tells cluster in three surfaces: Math.tanh, every CSS trig function, and Web Audio, where the Accelerate FFT carries the CPU architecture and the compressor’s scalar libsystem_m carries the OS.

How to close it

No noise. Perturbing the output fails twice. A reference comparison sees a value that matches no real OS, and per-call randomness breaks determinism, which is its own tell. The target is a value identical to the OS you claim, which noise cannot produce.

Reproduce the algorithm exactly. Recover the target’s minimax coefficients, exponent tables, and reduction constants from its libm, and transcribe them to portable C. Match every bit, including the inputs where the target rounds the wrong way. Here is Apple’s sin polynomial, coefficients pulled straight out of libsystem_m:

// Every fused multiply-add Apple emits is written as an explicit fma(). The
// bit pattern of each coefficient is copied verbatim; a decimal transcription
// would round differently.
static const double P[6] = {
     0x1.5d8fd1fd19ccdp-33, -0x1.ae5e5a9291f5dp-26,  0x1.71de3567d48a1p-19,
    -0x1.a01a019bfdf03p-13,  0x1.111111110f7d0p-7,  -0x1.5555555555548p-3,
};
static double sin_poly(double x2) {
  double p = fma(x2, P[0], P[1]);
  p = fma(x2, p, P[2]);
  p = fma(x2, p, P[3]);
  p = fma(x2, p, P[4]);
  p = fma(x2, p, P[5]);
  return x2 * p;                 // caller finishes: sin(x) = fma(x, x2*p, x)
}

Make it deterministic. That explicit fma() matters. Compile with FMA contraction off (-ffp-contract=off) so the compiler never invents or drops a fusion of its own. Now the fused ops are exactly the ones Apple fuses, and the result is identical on FMA11 and non-FMA CPUs, and identical between the ARM machine you imitate and the x86 fleet you run on. Hardware FMA and correctly-rounded software FMA return the same bits.

When reproduction is not worth it, lift the original. Windows UCRT is x86-64, the same ISA as a Linux server, and position-independent. Map the genuine ucrtbase.dll into memory at runtime and call its exports directly. The bits are genuine because the code is genuine, no reverse-engineering required.

Calling into Windows code from a Linux binary hits the ABI boundary. UCRT is compiled for the Windows x64 convention: the callee owns 32 bytes of shadow space above the return address, and the callee-saved register set differs from System V. Declare the function pointers ms_abi or clang’s frame layout gets corrupted by the callee’s shadow-space writes, and the indirect call jumps into garbage.

// Windows x64 ABI, not System V. Without ms_abi the call crashes.
typedef double(__attribute__((ms_abi)) * D1)(double);          // tanh, sin, ...
typedef double(__attribute__((ms_abi)) * D2)(double, double);  // atan2

// The mapped DLL code is not a CFI-registered indirect-call target, so
// -fsanitize=cfi-icall (on in production) #UD-traps every call -> SIGILL at
// startup. Opt the wrappers that call through the pointers out of that check.
[[clang::no_sanitize("cfi-icall")]]
double ucrt_tanh(double x) {
  return ucrt.loaded ? ucrt.tanh(x) : std::tanh(x);
}

One more detail decides correctness. Every UCRT math function starts with mov eax, [rip+disp32], reading a CPU-dispatch flag that selects the scalar or the FMA/AVX2 code path. A fresh mapping leaves it at zero, so you get the slow path, whose bits differ from what a modern Windows box produces. Extract the flag’s address from the tanh prologue and force it to the FMA path before the first call, and the lifted library matches a real Windows machine bit-for-bit.

Patch the chokepoint, gate it. Hook the single function that owns the value, where the engine calls libm. Gate on the claimed OS: Linux keeps glibc, Mac gets the reproduction.

Watch the clock. A perfect reproduction that runs slow is still a tell. Our first build lowered every fma() to a software call, because the default x86 baseline predates hardware FMA. That ran 2.5 to 6 times slower than native. A loop timing Math.tanh against Math.sin would show a ratio no real browser has. Turning on hardware FMA cut each fused op to one instruction: about 6 times faster, faster than glc, and bit-identical.

Validation

None of this ships without proof. Our harness runs 871,000 inputs per release across every branch and domain: dense grids, interval boundaries, subnormals, signed zeros, infinities, NaNs. Two ground truths back it:

1. A genuine-device oracle: a real Mac computing both scalar and Accelerate results for every input, so we know exactly where the two disagree.
2. A genuine-browser anchor: real Chrome on a real Mac over the debugging protocol, computing Math.tanh and every CSS trig function at full precision. This is the surface a fingerprinter reads.

We ship at bit-for-bit parity with genuine Mac Chrome on Math.tanh and on CSS sin, cos, tan, asin, acos, atan, and atan2, with the reproduction verified identical to the machine code in the shipped binary. Domain edges get checked too: asin(2) on a real Mac resolves to 0 (out of domain is NaN, and CSS clamps NaN to zero), not the 90 degrees a naive reproduction returns.

Why it matters

Math is deterministic, cheap to probe, hard to fake, and almost never on a spoofing stack’s radar. That makes it a strong signal for a defender and a liability for a scraper. Getting it right takes reverse-engineering vendor libm internals, mapping how three engines route math per call site, matching algorithms to the last bit, holding determinism across architectures, and proving it against real hardware.

Scrapfly’s browser carries all of it. Send a request through our API and ask to present as macOS, and the identity holds down to the rounding of a cosine.

Scrapium is Scrapfly’s scraping browser, built to stay indistinguishable from real traffic. Our engineering blog goes deep on the rest of the stack.

---

1. glibc: the GNU C Library, the standard C library and libm on most Linux systems. Reference: gnu.org/software/libc. ↩︎
2. ULP (unit in the last place): the gap between two consecutive representable floating-point numbers at a given magnitude. “1 ULP off” is the smallest difference a double can express. Reference: Wikipedia. ↩︎
3. fdlibm: Sun Microsystems’ “Freely Distributable libm”, the portable reference implementation of the C math functions. V8 carried a port of it and computed Math.tanh with it until Chrome 148, returning identical bits on every OS. Reference: netlib fdlibm. ↩︎
4. IEEE 754: the floating-point standard. It fixes how a double is stored but does not require transcendental functions to be correctly rounded, which is the room every vendor’s libm fills differently. Reference: Wikipedia. ↩︎
5. libm: the C standard library’s math module (sin, cos, exp, tanh, and so on). Each OS ships its own build, which is why the same call returns different bits: glibc on Linux, Apple libsystem_m on macOS, UCRT on Windows. Reference: C mathematical functions. ↩︎
6. minimax polynomial: the approximating polynomial that minimizes worst-case error. Each libm picks its own coefficients, and that choice is where the differing bits originate. Reference: Wikipedia. ↩︎
7. UCRT (Universal C Runtime): Microsoft’s C runtime (ucrtbase.dll) and its math functions. Being x86-64 and position-independent lets it be mapped into a Linux process and called directly. Reference: Microsoft Learn. ↩︎
8. V8 / Blink: Chrome’s JavaScript engine (routes Math.* through llvm-libc) and Chromium’s rendering engine (owns CSS calc() trig, which calls the host libm directly). References: v8.dev, chromium.org/blink. ↩︎
9. llvm-libc: LLVM’s C library. V8 statically links its math routines, so Math.sin, cos, exp, and pow are identical on every OS, which is why only Math.tanh leaks. Reference: libc.llvm.org. ↩︎
10. Accelerate framework: Apple’s vector and DSP library (vvsin, vvtanh, vDSP). It backs only the Web Audio FFT, not the scalar Math.* calls, which is why the scalar and vector results disagree. Reference: Apple Developer. ↩︎
11. FMA (fused multiply-add): a single instruction computing a*b+c with one rounding instead of two. Compiling -ffp-contract=off stops the compiler adding or dropping fusions, which is what makes the reproduction bit-stable across CPUs. Reference: Wikipedia. ↩︎

Ghostel is an Emacs terminal emulator powered by libghostty-vt - the same VT engine that drives the Ghostty terminal. A native dynamic module written in Zig handles terminal state, rendering, and local PTY I/O; Elisp manages keymaps, buffers, commands, and remote process integration.

Ghostel is inspired by emacs-libvterm and follows the same two-layer design, but uses Ghostty's modern VT engine instead of libvterm. This brings the Kitty keyboard and graphics protocols, rich underline styles, OSC 8 hyperlinks, OSC 4/10/11 color queries, and synchronized output (DEC 2026) - none of which libvterm supports. See Ghostel vs vterm and eat for a detailed comparison.

The native module is downloaded automatically on first use, so no toolchain is required for the common case. Open a terminal with M-x ghostel.

1. Quick Start

(use-package ghostel
  :bind (("C-x m" . ghostel)
         :map ghostel-semi-char-mode-map
         ("C-s"  . consult-line)
         ("M-<backspace>" . ghostel-backward-kill-word)
         ;; ;; I'm used to go up/down the shell history with M-n/p from eshell
         ;; ;; Simulate this behavior in ghostel by sending C-p and C-n
         ("M-p" . (lambda () (interactive) (ghostel-send-key "p" "ctrl")))
         ("M-n" . (lambda () (interactive) (ghostel-send-key "n" "ctrl")))
         :map project-prefix-map
         ("m" . ghostel-project)
         ("M" . ghostel-project-list-buffers))
  :config
  (defun ghostel-send-C-k-and-kill ()
    "Send `C-k' to ghostel.
Like normal Emacs `C-k'.  Kill to end of line and put content in kill-ring."
    (interactive)
    (kill-ring-save (point) (line-end-position))
    (ghostel-send-key "k" "ctrl"))

  (add-to-list 'project-switch-commands '(ghostel-project "Ghostel") t)
  (add-to-list 'project-switch-commands '(ghostel-project-list-buffers "Ghostel buffers") t)
  (add-to-list 'ghostel-eval-cmds '("magit-status-setup-buffer" magit-status-setup-buffer)))

(use-package ghostel-eshell
  :hook (eshell-load . ghostel-eshell-visual-command-mode))

(use-package ghostel-compile
  :hook (after-init . ghostel-compile-global-mode))

(use-package ghostel-comint
  :hook (after-init . ghostel-comint-global-mode))

If you are an evil user you can install the evil-ghostel extension:

(use-package evil-ghostel
  :after (ghostel evil)
  :hook (ghostel-mode . evil-ghostel-mode))

1.1. Shell integration at a glance

Directory tracking and prompt navigation are automatically on by default for local bash, zsh, or fish sessions. See shell integration for TRAMP support and more.

To call Emacs functions from your shell you have to add them to the ghostel-eval-cmds whitelist and then add something like this to your bashrc:

if [[ "$INSIDE_EMACS" = 'ghostel' ]]; then
    # Open a file in Emacs from the terminal
    e()   { ghostel_cmd find-file-other-window "$@"; }

    # Open dired in another window
    dow() { ghostel_cmd dired-other-window "$@"; }

    # Open magit for the current directory
    gst() { ghostel_cmd magit-status-setup-buffer "$(pwd)"; }
fi

1.2. Input modes at a glance

Ghostel offers five eat.el-style input modes.

The default is semi-char mode, which forwards almost all keys to the terminal besides a few exceptions (e.g. M-x, C-c).

In char mode, all keys go to the terminal. Press M-RET to exit.

In line mode Ghostel behaves like M-x shell: the buffer is a normal Emacs buffer and no key is sent to the terminal. Only after you finish typing a line and press RET is the whole line sent to the terminal at once.

emacs mode and copy mode make the buffer temporarily a normal Emacs buffer that you can use to navigate, look around, and copy text. The difference between the two is that copy mode freezes the terminal, so if you have continuous output nothing "scrolls away" while you try to select something. emacs mode is live, so new output keeps coming in while you scroll and select.

Those read-only modes have ghostel-readonly-fast-exit enabled by default (it defaults to t), which automatically exits them on most keys that you expect to be sent to the terminal. This makes for seamless transitions: say you have some output running and see something you want to copy - you press C-c C-t to enter copy mode, navigate like in a normal Emacs buffer, and select your text. When you copy something or type any character you are automatically back in your normal ghostel terminal session. Some actions also activate copy mode automatically, like selecting with the mouse, navigating to hyperlinks (C-c C-p), or activating the mark.

2. Requirements

• Emacs 28.1+ with dynamic module support
• macOS, Linux, FreeBSD, or native Windows

The native module is automatically downloaded on first use. Pre-built binaries are available for:

• aarch64-macos (Apple Silicon)
• x86_64-macos (Intel Mac)
• x86_64-linux
• aarch64-linux
• x86_64-freebsd
• x86_64-windows
• aarch64-windows

If you prefer to build from source or need a different platform, you will also need Zig 0.15.2 - see Building from source.

3. Installation

3.1. MELPA

(use-package ghostel
  :ensure t)

3.2. use-package with :vc (Emacs 30+)

(use-package ghostel
  :vc (:url "https://github.com/dakra/ghostel"
       :lisp-dir "lisp"
       :rev :newest))

:lisp-dir "lisp" is only required on Emacs < 31.1.

3.3. use-package with :load-path

(use-package ghostel
  :load-path "/path/to/ghostel/lisp")

3.4. Manual

(add-to-list 'load-path "/path/to/ghostel/lisp")
(require 'ghostel)

Then M-x ghostel to open a terminal.

3.5. Native module

When the native module is missing, Ghostel offers to download a pre-built binary or compile from source. This is controlled by ghostel-module-auto-install (default ask). You can also trigger these manually:

• M-x ghostel-download-module - download the minimum supported pre-built binary.
• C-u M-x ghostel-download-module - choose a specific release tag (leave blank for the latest).
• M-x ghostel-module-compile - build from source via zig build.

By default the module is read from and written to the package directory. If your package manager rebuilds or reinstalls the tree while Emacs has the module loaded, point ghostel-module-directory at a stable location outside the package tree (for example ~/.config/emacs/ghostel/).

3.6. Platform notes

3.6.1. Windows

Ghostel supports native Windows Emacs builds with dynamic module support. The pre-built release modules target the common x86_64 and aarch64 native Emacs architectures; the module DLL must match the architecture of Emacs, not merely the architecture of Windows itself. Unusual custom Emacs builds, including static-CRT builds, are best-effort.

Local terminals use Windows ConPTY. Ghostel first looks for support files from Microsoft's redistributable console runtime next to the native module (conpty.dll and the matching OpenConsole.exe helpers). When present, those files provide newer ConPTY behavior than older inbox Windows versions and can improve both interactivity and terminal-protocol correctness. If they are not installed, Ghostel falls back to the inbox Windows ConPTY API.

Downloading a pre-built Ghostel module also downloads the matching support files from the same Ghostel release. When compiling the module locally, Ghostel tries to install the latest available support files; failure to install them is non-fatal because the inbox ConPTY fallback remains available.

TRAMP remote terminals from Windows are limited to POSIX remotes. They use TRAMP/ssh rather than local ConPTY, so the PTY lives on the remote host. Dynamic window resizing for Windows-to-TRAMP terminals is not currently supported.

4. Building from source

Building is only needed if you do not want the pre-built binaries. Ghostel vendors a generated vendor/emacs-module.h, so normal builds do not require local Emacs headers.

git clone https://github.com/dakra/ghostel.git
cd ghostel

# Build everything into the checkout (fetches ghostty automatically)
zig build --prefix . -Doptimize=ReleaseFast

To override the vendored Emacs header, set EMACS_INCLUDE_DIR to a directory containing emacs-module.h, or set EMACS_BIN_DIR to an Emacs bin/ directory

• Ghostel then looks for ../include and ../share/emacs/include.

To build against a local ghostty checkout, temporarily point the dependency at your local path:

zig fetch --save=ghostty /path/to/ghostty
zig build --prefix . -Doptimize=ReleaseFast

The module and ghostel-module.version sidecar are installed under Zig's install prefix. Use --prefix . when building into a checkout that Ghostel should load directly, or pass another prefix matching ghostel-module-directory. On Windows, local builds normally use Zig's MinGW target (for example -Dtarget=x86_64-windows-gnu) so they match common native Emacs builds and do not require a Windows SDK.

When installed from MELPA, M-x ghostel-module-compile builds the native module from source using zig build --prefix <ghostel-module-directory>; the Zig package manager fetches the ghostty dependency automatically.

4.1. Bundled terminfo

The compiled xterm-ghostty terminfo entry ships pre-built in etc/terminfo/ and is identical to what tic would produce locally - no build step needed, and the file format is portable across BSD and ncurses systems. Maintainers regenerate it via make regen-terminfo after bumping libghostty.

Today we’re announcing protobuf-py, a Protocol Buffers library for Python written completely from scratch. It passes every binary and JSON case in the Protobuf conformance suite across proto2, proto3, and editions, and it supports extensions, custom options, unknown fields, dynamic messages, and well-known types. It generates readable, typed Python, has no runtime dependencies, and runs on pure Python 3.10+. With its Rust accelerator installed, it’s just as fast for production workloads as upb, the C engine Google’s Python package runs on.

For Python developers, the choice has historically been between a complete Protobuf implementation and a library that feels like Python. Google’s package is complete, but it carries an API shaped by C++ and Java. betterproto is pleasant, but it gives up too much of the spec. protobuf-py gives Python developers both.

Why build another Protobuf runtime?

Python is too important for Protobuf to feel like an afterthought. It sits in data pipelines, ML systems, AI agents, infrastructure scripts, RPC services, and developer tooling. Still, the experience of using protobuf in Python does not match what developers expect from such a popular language. Google’s package is complete and battle-tested, but the API and generated code still feel like a binding around someone else’s runtime. betterproto proved that Python developers wanted something nicer, but it never implemented the whole spec. grpcio brought the same problem into RPC. It’s powerful and widely used, but painful to build around.

We originally set out to fix the RPC layer with connect-py, a ConnectRPC implementation that speaks both Connect and gRPC. But the transport layer was not enough. A good RPC stack still depends on the messages underneath it, and Python did not have the Protobuf runtime we wanted as the foundation. We wanted something complete enough for real schemas, readable enough for everyday Python, and fast enough that nobody has to apologize for choosing it.

protobuf-py is the result of asking whether those constraints could all be true at once. A complete implementation built for Python, it provides the spec coverage, generated code, and performance profile we wanted connect-py to stand on, without wrapping Google’s runtime or trimming the spec.

Why Google’s package feels the way it does

Install protobuf from PyPI and the engine you normally get is upb, written in C. Your message lives in a C arena, while the Python object is a handle into that arena. Reading a field crosses into C, finds the value, and materializes a Python object on the way back.

It is a good way to share an engine among multiple languages, but it leaves fingerprints everywhere:

• Generated _pb2.py files are hard to read because there is not much Python to read. Classes are assembled at import time to configure the C engine, so go-to-definition lands on a wall of serialized descriptor bytes.
• SerializeToString, HasField, WhichOneof, and CopyFrom make up a Python API designed for C++ ergonomics. HasField raises if you call it on a proto3 scalar. WhichOneof returns a string you hand back to getattr to retrieve a value it already located.
• Generated imports are absolute and break the moment you nest them in a package. There is a separate tool called fix-protobuf-imports that exists on PyPI only to rewrite Google’s output.
• Types register in one process-wide pool, so importing two builds of the same .proto raises at runtime.

None of these are random defects in the binding. They are what happens when a Python API is designed for consistency in a primarily C++/Java codebase, rather than as an idiomatic Python package. The clumsy API and the speed shipped together, and for years you took both or neither.

What we built instead

protobuf-py keeps your message in Python. It is a plain object with __slots__, and its fields are ordinary Python values: ints, strings, lists, submessages. A Rust accelerator speeds up the operations that need it, mostly parsing and serializing, and writes the results straight into the object. Once parsing finishes, reading a field is just accessing a Python attribute.

Because the data is Python, the generated code is real code. protoc-gen-py emits a class you can read:

class User(Message[_UserFields]):
    __slots__ = ("first_name", "last_name", "active", "manager", "locations", "projects", "contact")
 
    if TYPE_CHECKING:
        def __init__(
            self,
            *,
            first_name: str = "",
            last_name: str = "",
            active: bool = False,
            manager: User | None = None,
            locations: list[str] | None = None,
            projects: dict[str, str] | None = None,
            contact: Oneof[Literal["email"], str] | Oneof[Literal["phone"], str] | None = None,
        ) -> None: ...
 
        first_name: str
        last_name: str
        active: bool
        manager: User | None
        locations: list[str]
        projects: dict[str, str]
        contact: Oneof[Literal["email"], str] | Oneof[Literal["phone"], str] | None

Working with it looks like working with anything else in the language:

import copy
from gen.user_pb import User
from protobuf import Oneof
 
user = User(first_name="Alice", active=True, locations=["NYC", "LDN"])
user.last_name = "Smith"
 
wire = user.to_binary()
parsed = User.from_binary(wire)
 
match parsed.contact:
    case Oneof(field="email", value=email):
        send(email)
    case Oneof(field="phone", value=phone):
        call(phone)
 
inactive = copy.replace(parsed, active=False)   # Python 3.13+

Oneofs become values you can pattern-match, and the type checker narrows each branch. Enums are real IntEnum members. pyright, mypy, and ty read the generated output without a stubs package. Generated files use relative imports and go wherever you keep them. Types resolve through an explicit Registry rather than a global pool. Every one of these follows from keeping message data in Python.

It is complete, not a friendly subset

Other Protobuf libraries are nicer to use than Google’s, but usually drop half the spec to get there. betterproto is the most pleasant option today and it is proto3-only, with no proto2, editions, extensions, or custom options.

protobuf-py covers the whole spec. It handles proto2, proto3, editions, extensions, custom options, groups, unknown-field preservation across round trips, packed and expanded repeated fields, and the full ProtoJSON encoding of the well-known types. It passes the conformance suite Google uses to qualify its own runtimes, with no failures across binary and JSON. An empty failure list is checked into the repository, and CI fails if it stops being empty.

Fast where it counts

A benchmark that parses a message and throws it away makes upb look untouchable, because it defers work until you read. Production code parses a message once, branches on fields, pulls out a few values, copies the message, and serializes a modified version back.

upb pays the Python translation cost on every one of those reads. protobuf-py pays it zero times after the first read, because parsing already produced a normal Python object. The cost runs the other way at the boundary. Keeping data in Python means protobuf-py does more work up front. That pays off when code does enough with a message to earn the time back.

Here we put both packages against a real-world example of building the response for a user’s home page on a social media site, alongside the raw marshaling steps on their own. Numbers are throughput (operations per second) relative to upb, so higher is faster.

Workloadupbprotobuf-pyBuild home page response (end-to-end)1.0x1.06x└ parse (in isolation)1.0x0.22x└ serialize (in isolation)1.0x0.60x

In isolation, upb wins marshaling, exactly as expected. End-to-end, on the code a service would actually run in production, protobuf-py comes out ahead. Every field read that upb has to translate back into Python is one protobuf-py already has, and across a full request that adds up to a runtime that can beat the C one.

The payload here is text-heavy (full Reddit post bodies, multi-sentence bios and notifications), which is the realistic shape of social, document, and LLM/agent traffic. This is the case where keeping strings as Python objects pays off most. You can run the harness yourself at test_bench.py.

The Rust accelerator is optional and automatic. You do not need a Rust toolchain to use protobuf-py, and neither do contributors. Prebuilt wheels load it when it is there, and a pure-Python path behaves identically when it is not. It runs on the free-threaded 3.14 build, and the package has no runtime dependencies.

We have done this before

Buf has spent years fixing the parts of Protobuf that make teams build scripts around their tools: the Buf CLI, the Buf Schema Registry, ConnectRPC, Protovalidate, and protobuf-es for TypeScript. Buf engineers also worked on Protobuf editions, so protobuf-py is written by people who helped write the spec. It belongs to the same tradition.

Try it

# In your existing UV project
uv add protobuf-py
uv add --dev protoc-gen-py buf-bin

Point a buf.gen.yaml at your .proto files:

version: v2
inputs:
  - directory: proto
plugins:
  - local: protoc-gen-py
    out: gen

Then generate:

uv run buf generate

You get a typed _pb.py you can open and read. Docs are live, the source and benchmark harness are on GitHub, and the issues are open. Let us know how it goes for you!

On the journey from books to screens and back

400 Blows (1959), directed by François Truffaut.

---

I hit my reading peak when I was eleven or twelve. At the time, it was a joke. I had a bedside table and it was stacked with books, all at different stages of being read. Books migrated to the floor next to the bed, and different stacks migrated to different rooms of the apartment. At the time I really was ravenous. It was clear to me that books were essentially the same as knowledge and were the window into the world—into all kinds of different worlds—but, crucially, that books also contained the key into adulthood. Since then, my reading has basically been in decline and under siege from a wide variety of different adversaries. Let’s list those before getting into my personal reading rehabilitation project.

Middle school, and adolescence in general, were the single greatest blow to my reading. It quickly became clear that, from a social perspective, all this reading was a catastrophic blunder, and I tried to switch gears as quickly as I could—I would come home from school and turn on ESPN or VH1 and try to download pop culture so that I could repeat it back in school the next day.

School itself was an obstacle to my reading. I showed up at my new middle school trying to hide The Republic under The Red Pony, and I’ve had a fantasy from that day to this that the school system would start recognizing and supporting kids like me who clearly were very self-motivated and had an obvious aptitude in one subject as opposed to others. In this fantasy I would have been instantly enrolled in some higher-level English classes and excused from math or science, which, it was completely clear, wasn’t going to be a significant part of my life. But that just wasn’t the case. There were phone calls home, and I learned fairly quickly to revert to the mean.

Then there was social life. I remember carefully packing a suitcase of my books for college when my father told me, “Trust me, there won’t be a moment for reading recreationally.” He didn’t just mean that there would be a deluge of school reading, he meant that there would be so much going on around campus that reading for fun would be a kind of admission of social failure. I took that seriously, felt a sort of guilty conscience whenever I opened up one of my books and tried to think what I should be doing instead. It was a real surprise to me when I realized, somewhere towards sophomore or junior year, that it wasn’t exactly true and lots of cool, perfectly socially-adjusted people were also reading for fun.

Illustration by Sam Keshishian.

Then there was work life. I sort of had an understanding around this time that reading, even serious reading, was childish, and that adults spent all their time thinking about money, and I remember a moment soon after I graduated when I delivered a kind of private eulogy for my reading life. In the end, it turned out to be not like that. The first job I had out of college involved twelve-hour workdays, but that still left a lot of hours unaccounted for, and I remember the curious guilty pleasure of visiting the used bookstore in town and loading up on a whole bunch of Penguin Classics that the proprietor was visibly surprised to be selling to anyone.

I remember feeling like I’d overcome some kind of hurdle in my reading life at that time—I’d expected work life to grind down my reading and instead my reading (which is to say, my inner life) had somehow outfoxed the work schedule. But I was underestimating my adversaries. That phase was another peak of my reading, and then there was a ten-year period from, roughly, my late twenties to my late thirties when I barely read anything at all—or, at least, my reading consumption slowed to a level that would have deeply embarrassed my eleven-year-old self.

What happened? I was no longer in terror of middle schoolers expecting me to know who Gwen Stefani was or to quote TV commercials back at them. I wasn’t, for the most part, dealing with an onerous worklife that swallowed up all my free time. But there were a few new adversaries.

One was love. Being with a partner meant, essentially, turning over my inner life to the partner. Reading seemed like a way of distancing rather than connecting, and by far the better way to consume content was to stream TV shows together.

Then there were money worries. Adulthood wasn’t quite the grey-flannel-suit enterprise that I had pictured where I was younger, where you entered into the workforce and were essentially lobotomized by it. In millennial life everything was a bit looser and freer, but there was also a drumbeat of constant anxiety. Reading—I mean, reading a long, serious book—seemed, in that context, like checking out, not so different from sitting down on the street and rattling an empty coffee cup. Scrolling was alright—that meant that you were still plugged in, that you were part of the flow of life, where social connections and money opportunities could be made. But there was absolutely zero opportunity of advancing one’s interests by reading a book—there was no conceivable social chit-chat that would turn to people bantering about books, and the knowledge in books was entirely abstract and remote, as opposed to the potentially utilitarian knowledge you might get from a newspaper or a social media post.

From a more macro point of view, what was happening at this time was the final breakdown of a Bourdieauian concept of social status, in which taste was the critical metric of status and being bourgeois or refined meant, among other things, being a reader (for a glimpse of how a Bourdieuian social system worked in practice, it’s worth watching certain movies from the ’70s or ’80s, any Woody Allen movie, for instance, which are basically a cornucopia of high-brow referents). As David Brooks nicely documents in Bobos in Paradise, the bourgeoisie made a kind of collective pact around the 1990s or 2000s to just drop it—to not burden themselves with showing off how much they’d read and to instead just flaunt their wealth while entertaining themselves with talking about TV shows, which were starting to become pretty good.

Then, surprisingly enough, writing was a hindrance to my reading. This is kind of a specialized concern, but I came to feel in my twenties that my writing was a bit drafty and undergraduate, in large part because I was overly influenced by the enormous swath of reading material that I had inhaled through my adolescence. I was very impressed by a line from a medieval Arabic poet where he advises a student to memorize a thousand passages of poetry and then to forget them all again before he could begin writing. I decided that I was in the phase where I needed to forget—I had taken in too many inputs, and I had a tendency to be intimidated or just overly influenced by them, and now was the time, I felt, to clear out my own head and find my voice. This, by the way, I think is pretty good advice to writers, but, at the time, it was accompanied by a certain bitterness on my part towards reading—if reading couldn’t even make me a better writer, I thought, then what really was all that reading for?

But, of course, the most significant obstacle to reading was social media. There was a long period of time—almost forgotten now—where society split between those who were always online and those who weren’t. I prided myself in being among the people who weren’t—having a Facebook profile but not posting, not obsessively checking Twitter, etc.—but we were all fooling ourselves. The turning point for me came when I watched the documentary The Social Dilemma in 2020 and realized the extent to which I was like the kind of alcoholic who claims that they only drink moderately, but whose life is in fact dominated by booze. “Every time you see the phone on the counter and you just look at it and you know if you reach over it just might have something for you so you play that slot machine to see what you get, right?” the technology ethicist Tristan Harris says in the documentary. The argument was that the phones used deep psychological techniques—it’s called “positive intermittent reinforcement,” if you’re interested—to get you completely hooked. I was old enough to remember how the arrival of the mail in the morning had a similar effect on people, or the way that people might hover by a landline waiting for a phone call. But now it was like people were checking their mailbox a thousand times a day—just the idea of good news coming for you, and only you, was so powerful that, essentially, nothing else could compete with it, certainly not a closed form like a book, which as often as not was written by a dead person and, by definition, could not have a job offer or a romantic possibility or a party invitation or a compliment for you embedded within it.

Illustration by Sam Keshishian.

For the better part of a decade, we all fell victim to this. I remember the most interesting person I knew—a guy who’d become a shaman—saying that his whole spiritual journey was behind him. “Now I am a Facebook customer,” he reported. And my reading habit was one victim of many.

The Social Dilemma probably was the decisive event for me and made me realize the extent to which my behavior—the regular checking of my cell phone—was addiction, no matter that I was probably a bit better than most people I knew. The period since then—call it the last five years—has been a slow and deeply embarrassing journey to learn to read again. In other words, painstakingly and through all kinds of cheap tricks, to learn to do something that used to be about as natural for me as breathing. I sometimes think about it as being like a stroke victim who has to train themselves to walk again or to wake up some dormant hemisphere of their brain—with the difference that nothing bad happened to me, apart from the general current of 21st century life.

What bothered me most, I suppose, was the degradation of my own inner world. Solitude used to be something I looked forward to—the chance to curl up with a book. Now I was twitchy and irritable—constantly checking my phone. I was, in a word, far less mature than I had been when I was eleven or twelve. I could remember when adults might ask each other, as a normal question, “what are you reading?” and that was like an invitation to travel together into a different dimension, into the content of each other’s inner lives and each other’s souls. Asking each other about what they had seen on Netflix or whether they had caught the Grammys didn’t have the same incantatory power. Without that, discourse seemed to be breaking down. Twitter was turning into a flaming mosh pit of dueling online mobs, Instagram and Facebook were aggressively performative, and all of them were heavily manipulated by algorithms and subject to corporate censorship. What reading really meant was getting away from all of that—from an opportunistic culture in which participants are “users” and to the promise that’s embedded in reading at its best, of soul speaking to soul, of individuals maybe continents or centuries away speaking their truth, to the best of their ability, and being received with respect and empathy by an attentive reader. To me, that seemed like a much better, more reciprocal and more honorable, relationship with others than anything that was on offer from my current tech-based social landscape.

So, in my uphill battle to once again be a reader, here are a few of the tricks I’ve tried.

The first and most important is that I’ve given myself over almost entirely to motivated reading. It’s almost impossible for me now, as it has been for years, to just pick up a book and to fall into the kind of daydreaming state that coffee mugs and coasters are always proclaiming is the essential joy of reading. If I’m reading it’s always for something and—like I’m the manic Duolingo bot constantly creating random milestones for its users—I’m always giving myself tasks to complete in my reading. I often read as research for writing projects, and that is no problem at all—I am able to read just as fluently and frenetically as when I was a kid or, probably more precisely, as when I was a student cramming for an exam. That’s a very specific, and more or less healthy, way of reading. I know that I have a limited time to research a project before it gets stale in my imagination—I want to be comprehensive in my research without getting bogged down in it—and I read in a totally voracious way. Here, the internet actually is my friend: between archive.org and Everand and weird piratic sites like Dokumen, I can find with rare exceptions any text I am looking for (and which would have been hopelessly tedious in the pre-internet era of moving between libraries or asking for books on inter-library loan).

Then, I make myself turn out a product nearly every time I read something. The origin of my Substack—on which I write prolifically—is largely that I was looking for a place to post book reviews, and the reason I wanted to post book reviews was that I wanted to give myself a reason to read the books in the first place. The difference between reading “for pleasure” and reading with a review envisioned at the end of a project is considerable. For one thing, I am a much more attentive and careful reader when I am planning to write a piece on the book—and know that I will be judged if I skip over a key plot point or misread the book (and may even face a critique from the sulky author themself). I read in an almost-industrial style when I am reading this way (which is, at this point, the vast majority of my reading). And here, once again, technology is my friend. In the pre-smartphone days, I had always been perplexed by whether and how much to write in the margins of books I was reading—which seemed disrespectful and also like the primrose path to being a pack rat. But with Apple Notes, I write down basically everything that’s interesting to me in the book as I’m reading and swipe-typing picks my speed up enough that I don’t really lose my flow in a book as I’m writing my note. The result is that I can basically write a review as I’m reading a book, and—when it comes time for the review—I often don’t even look at the book again. I can do it entirely off my notes.

But even that technique is only partially successful. I started my Substack planning for book reviews to be a cornerstone of it, but if I look back at my archive, whole months can pass without my writing a review of anything—which means that I’m basically not finishing any books at all. A few things are going on at once. One is that I get really depressed over the state of contemporary writing, especially contemporary fiction. Anybody who’s tried to write reviews, or binge contemporary fiction, will know what I’m talking about. But the more salient point is that I still am a digital addict. If I’m on my phone, or a computer, my impulse is to check mail for the thousandth time that day or to play games online or to scroll the newspaper or to hang out on Substack Notes. So I started a new round of embarrassing addiction-control reforms. After watching The Social Dilemma, I’d taken their advice and turned off Notifications on my phone, which, actually, was a life-changer. Now, like I was my own parent, I started different regimens for increasing my reading time. I would open up a book on my e-mail or Kindle, and then, once I did, put the phone in airplane mode and then force myself to read for fifty pages or a half-hour at a time, something like that. It wasn’t easy at all, and—at the time of writing this—it’s very much a work in progress. Somehow or other, that airplane mode button keeps getting toggled off. If I don’t force myself to take notes on a book—with the prospect of writing a review at the end of it—it’s easy for me to zone out for whole pages at a time, still reading but not processing what’s happening. It’s an astonishing come-down—my regression from being the best reader of anybody I knew to being the kind of C student whose parents were always tricking them into doing their English homework—but we are far enough into the great cultural collapse that I just have to accept what’s happening and adapt to it. Reading has become something that I have to force myself to do.

The question then becomes—and I do find myself asking it a lot—why I bother at all. Why do I read, if it’s not particularly good for my career or my social life, or even for my writing, and I often don’t even enjoy it, and have to find these inane tricks to compel myself to do it? What I’d like to say is that somewhere in me is the same compulsive curiosity that first animated me to become such a great reader back when I was a little kid, but I think the answer is a bit different and is more about feeling a kind of obligation. Civilization is facing an existential crisis. We have lost the habit of reading—if I had such a difficult time with digital addiction, I can only imagine what it was like for people who didn’t have the head start as a reader that I did—and that means that we lose both a capacity for deep concentration (which includes the capacity for jumping from our perspective to perceiving the world from the consciousness of others) as well as a critical continuity with the pre-digital past. These are really bad habits to lose. Anybody who’s encountered anybody below the age of, say, twenty-five will be struck at how their worldview seems to begin with the digital age, and what that means is that anybody who is older, or who has something like an ancestral memory of deep reading, has an obligation to serve as a caretaker generation, to keep the habit alive, with whatever tricks we can manage, in the dim hope that something or other will happen, that the entire culture won’t be swallowed up by social media algorithms and their A.I. successors, that somehow or other the taste and utility of reading, actual reading, will come back. Until then it’s airplane mode and timers and anything else we can think of that will force ourselves to read an actual book, and to resist the infinite allure of the infinite scroll.

Article cover spread from the print version.

So You Want to Learn Physics…

SECOND EDITION

Introduction to the Second Edition

Nearly six years ago, I sat down at my desk and typed up a detailed guide for anyone who wanted to learn physics on their own. At the time, I had no idea how many people would read it and use it — my only goal was to put the information out there in a clear and straightforward way so that anyone who wanted to learn physics would have the self-study curriculum they needed. Since then, over six hundred thousand people have turned to this guide to study physics.

According to the emails I’ve received from readers, many of you have gone on to get undergraduate degrees in physics after following the curriculum in this guide (some of you are even now in graduate programs!), but the majority of those who have bookmarked and followed this guide — even all the way to the end! — have done so out of pure curiosity and for the sheer joy of understanding the incredible universe we inhabit.

The success of this guide is, I believe, a testament to two things.

First, that one of the most impactful things you can do is to share what you know with others, even if it doesn’t seem like a lot. I wasn’t able to become a professional physicist, but I was able to use my knowledge of undergraduate and graduate-level physics to type up a comprehensive and accessible curriculum that has helped hundreds of thousands of people learn physics. That’s pretty remarkable. If you are wondering what you have to offer the world, I hope you will think of this guide and consider what you might know that you can share with others.

Second, that there are so many people in the world who want to understand physics but are unable to study it formally in a university setting for any number of reasons. These same people are very serious about learning physics, and not for any career purposes but simply because they want to understand the universe, and they are and have been dreadfully underserved and underestimated by the academic physics community (who do not take them seriously because they aren’t studying at colleges and universities) and by the authors of contemporary and popular physics books and the publishers of those same books (who mostly just sell them books that assume most readers can never and will never really understand physics). When I wrote the first edition of this guide, I was pretty sure there were a lot more people out there who really wanted to learn physics — real physics — than academic physicists and publishers believed, and those were the people I wanted to help. As it turns out, there were even more of you than I could ever have imagined!

Well, after almost six years and lots of reader feedback, I decided that it was finally time to make a (lightly) updated version of this guide. I went back through the emails and comments I’ve received over the years, and then made a list of the most popular requests. I skimmed through all the books in the curriculum and a few new ones as well. I updated textbook editions, added more undergraduate-level electives, added a section of graduate-level electives, and made a few other small changes — all in the hope that this new version will be even more useful than the first.

As I wrote in the first edition: “Remember that anyone can learn physics…Whether you turn it into a hobby or a career, the pure joy of understanding the universe around us is one of the most beautiful experiences you can ever have in life.”

Godspeed!

You can still find the first edition here, on my old website: https://www.susanjfowler.com/blog/2016/8/13/so-you-want-to-learn-physics.

Introduction to the First Edition

Over the past few years, ever since writing a blog post called “If Susan Can Learn Physics, So Can You,” I've been contacted by people from all backgrounds who are inspired and want to learn physics, but don't know where to start, what to learn, what to read, and how to structure their studies. I've spoken with single mothers who want to go back to school and study physics, tenured philosophy professors who want to learn physics so that they can make significant and informed contributions to philosophy of physics, high school students who want to know what they should read to prepare for an undergraduate education in physics, and people in dozens of various careers who want to really, really learn and understand physics simply for the joy of it.

This post is a condensed version of what I've sent to people who have contacted me over the years, outlining what everyone needs to learn in order to really understand physics.

The general physics education given in U.S. universities is divided into what is learned at the undergraduate level and what is covered in graduate courses, and I've divided my list in a similar way. Because each subject is built upon the previous subjects and the mathematics becomes more complex and difficult, it's important to learn each topic in the order presented below.

If you work through the all of the textbooks in the Undergraduate Physics list of this post, and master each of the topics, you'll have gained the knowledge equivalent of a Bachelor's Degree in Physics (and will be able to score well on the Physics GRE). If you work through the graduate core of the Graduate Physics textbooks, you'll have the equivalent knowledge of obtaining a Master's Degree in Physics. A PhD in Physics requires the graduate coursework as well as several years of research and a thesis, and the experience involved in a PhD isn't something that can be gained independently of a PhD program.

Remember that anyone can learn physics. It's no different from learning programming, from learning a musical instrument, from reading great literature. Whether you turn it into a hobby or a career, the pure joy of understanding the universe around us is one of the most beautiful experiences you can ever have in life.

Before You Begin

Popular Books on Physics

When you're solving problems, working through textbooks, and getting into the nitty-gritty details of each topic, it's so easy to lose the forest for the trees and forget why you even became inspired to study physics in the first place. This is where really, really good (and non-speculative) popular books on physics come in handy: they inspire, they encourage, and they help you keep the big picture in mind.

One big problem is that many popular physics books (especially those written by famous physicists) are incredibly speculative and tend to present an unrealistic view of what the study of physics is all about. When you're learning physics, it's best to avoid these types of speculative books and stick to the ones that talk about the real physics that we know exists (in general, anything by Frank Close or Richard Feynman is a safe bet!).

Here are a handful of my favorite popular physics books, ranked in order of difficulty:

• The First Three Minutes by Steven Weinberg (Level: Easy). An account of the Big Bang by one of the most brilliant physicists of all time.
• The Character of Physical Law by Richard Feynman (Level: Easy). A brilliant, inspiring little book on the laws of nature.
• The Particle Odyssey by Frank Close (Level: Easy). A brilliant popular introduction to particle physics and its history, beautifully illustrated with amazing figures and photographs. (Unfortunately it’s a bit difficult to find online right now, but if you find a copy, you should buy it ASAP!)
• Black Holes and Time Warps by Kip Thorne (Level: Easy/Medium). My absolute favorite popular introduction to general relativity.
• The Theoretical Minimum by Leonard Susskind and George Hrabovsky (Level: Medium). A solid introduction to classical mechanics. Is best understood around level 5 in the undergraduate curriculum.
• The Feynman Lectures on Physics (Boxed Set) and Feynman Lectures on Physics (Kindle Edition) (Level: Medium). Feynman's Lectures are essential readings for everyone interested in physics, and you'll find a copy on the bookshelf of every amateur and professional physicist. These lectures are what got me into physics: my astronomy professor told me to read them and see if I liked physics - they changed my life! They are somewhat difficult to understand if you are just getting started, but they will make more and more sense by the time you reach levels 5 and 6 in the undergraduate curriculum.
• Deep Down Things: The Breathtaking Beauty of Particle Physics by Bruce Schumm (Level: Difficult). The very best popular book about particle physics — it clearly explains the most difficult concepts without resorting to speculation. (I had the honor of working with Bruce on a search for supersymmetry at the ATLAS detector.) This book is a great read while you are starting level 7 in the undergraduate curriculum.

Mathematical and Scientific Preliminaries

Before you begin studying physics and working through the topics in the sections below, you need to be familiar with some basic mathematics. A high school education — which should include pre-algebra, algebra 1, geometry, algebra 2, trigonometry, and pre-calculus — is sufficient. If you need a refresher, I recommend either working through the Khan Academy math courses (https://www.khanacademy.org/) or the book Why Math? by R.D. Driver. There's no need to be familiar with calculus before starting, because you’ll learn it as you work through the undergraduate-level courses.

There are no scientific prerequisites for this curriculum. You don’t need to be familiar with biology or chemistry at either the high school or college level in order to understand, although doing some studying on the side can’t hurt. Khan Academy has some great high school science refresher courses that are perfect for this (https://www.khanacademy.org/science).

How to Study

Everyone learns very differently, and knowing your learning style is important: do you learn by reading, by taking notes, by talking, by watching, by doing, or by a combination of some or all of these? For example, I learn by reading and by note-taking, so I read through textbooks very carefully, take copious notes, and summarize each concept in my own words before moving on to something new. Think about this before you begin so that you'll know how to structure your studies.

Regardless of your learning style, you'll still need to solve the physics problems in each textbook. Solving problems is the only way to understand physics. There's no way around it. Even though it can feel tedious at times, there's nothing more rewarding than figuring out a really difficult physics problem and realizing that you figured it all out all by yourself!

One tough thing about learning on your own is that you may not know whether you are solving the problems correctly. Some of the textbooks listed below have answers to selected exercises in the back of the book, but these aren’t always adequate for two reasons: (1) they often only show the solutions to the problems, and not the steps taken to get there; and (2) it’s much better to do all of the exercises rather than just a select few. The good news is that many of the solutions (and step-by-step ways to solve them) can be found online with a simple Google search. If you are going to Google the answers, however, please first try to solve the problems on your own, and try multiple times (you’re not in school trying to get a perfect grade — you’re trying to learn and understand).

And, finally, a note on learning in a laboratory vs. learning from textbooks. Physics is both an experimental and theoretical science, and while research happens in laboratories and on blackboards and computers, the majority of any physics education does not take place in a laboratory but in lecture classes that teach from textbooks and assign homework problems that are found in textbooks. Yes, there are some laboratory classes (usually at the very introductory levels, and their only purpose is to show that oh, look, Newton’s laws work in the real world after all) and some — some — undergraduates are allowed to participate in research on the side, but physics is taught through textbooks, lectures, and homework problems. Don’t believe me? Take a look at the undergraduate physics curriculum at any university that offers a physics major. Graduate programs in physics are largely the same — both M.A. and PhD programs in physics require two years of core classes — with one key difference: to get a PhD, students need to complete several years of research, a thesis, and — at many programs — take an exam to prove they have mastered the graduate core curriculum. The graduate core curriculum is all textbooks and lectures and homework problems. The textbooks listed in the curriculum I’ve written below are the same textbooks that are used in the top undergraduate and graduate physics programs in the world. Studying them will give you the same education that you would receive at one of these programs — no painfully-annoying-introductory-mechanics-laboratory-class-with-inane-group-projects required.

Undergraduate Physics

Overview

The curriculum of every undergraduate physics program covers the following subjects (along with some electives in various topics), and usually in the following order:

1. Introduction to Mechanics
2. Electrostatics
3. Waves and Vibrations
4. Modern Physics
5. Classical Mechanics
6. Electrodynamics
7. Quantum Mechanics
8. Thermodynamics and Statistical Mechanics
9. Undergraduate Electives

I'm going to cover the details of each of these fields below, including the best textbooks to use and any additional reading you may find helpful in your journey. I'm also going to give some details about the mathematics you'll need to learn alongside each topic.

1. Introduction to Mechanics

What It's All About

An introduction to mechanics course is the first physics class that most people will take in an undergraduate program, and it's the best place to begin independent study of physics as well. This is where you'll start learning how to see the world in mathematical terms. Topics that will be covered: the basics of motion in a straight line, motion in two dimensions, motion in three dimensions, Newton's Laws, work, kinetic energy, potential energy, the conservation of energy, momentum, collisions, rotation and rotational motion, gravitation, and periodic motion.

The Best Textbooks to Use

• University Physics with Modern Physics by Young and Freedman (essential). Work through all of the "Mechanics" chapters (in my edition, these are chapters 1-14). This is the best introductory book I've found, and you can use it when you learn electrostatics and modern physics, too. It does a great job of introducing the relevant mathematics, but you'll need to be learning calculus alongside it. There are plenty of great example problems to work through, and the solutions are easy to find online (though you can also buy a Student Solutions Manual). Please note that you don't need to spend $250 on the new edition — Amazon has lots of copies of the 12th edition, the 13th edition, and the 14th edition that contain the same material.

The Math You'll Need to Learn Alongside It

You'll need to learn calculus while working through University Physics. My favorite introductory calculus book is Thomas' Calculus (you can also use the earlier editions), with Stewart's Calculus (older edition here) coming in as a close second. Work through each chapter, and make sure you can solve problems at the end of each chapter before continuing to the next.

If you are new to calculus and/or find yourself struggling to get accustomed to it, don’t let that stop you. Calculus is really difficult, and it can take a really long time to wrap your head around it. Some things that can help are (1) watching videos like the ones on Khan Academy (https://www.khanacademy.org/), (2) taking Robert Ghrist’s free calculus courses on Coursera, and (3) reading a truly amazing little book called Calculus Made Easy by Silvanus P. Thompson and Martin Gardner that breaks everything down really clearly.

2. Electrostatics

What It's All About

This is where you'll learn about the physics of electricity and magnetism (electromagnetism) in static situations (situations where no motion is involved). Topics covered are: electric charges and electric fields, magnetism and magnetic fields, Gauss's Law, capacitance, resistance and conductance, inductance, current, and how circuits work.

The Best Textbooks to Use

• University Physics with Modern Physics by Young and Freedman (essential). Work through the chapters on "Electromagnetism" (in my edition, these are chapters 21-32). You can find inexpensive copies of the 12th edition, the 13th edition, and the 14th edition that contain the same material.

The Math You'll Need To Learn Alongside It

Keep working through the calculus textbooks (Thomas or Stewart) while you work through the basics of electrostatics, but you should finish them by the time you finish the electromagnetism chapters in University Physics. You absolutely must understand the basics of calculus before you move on to the other topics in physics.

3. Waves and Vibrations

What It's All About

The mechanics of vibrations and waves are complex and important enough to demand their own course of study. Mastering this material is essential for learning about quantum mechanics, so don't skip this topic! This is where you will learn about simple harmonic oscillators, damped harmonic oscillators, forced oscillations, coupled oscillators, waves, interference, diffraction, and dispersion.

The Best Textbooks to Use

• Vibrations and Waves by French (essential) and Vibrations and Waves by King (essential). These two books complement each other very well, and contain different problems and solutions.

The Math You'll Need To Learn Alongside It

By this point, you should have finished the introductory calculus books and are ready to move on to more advanced mathematics. You should start working through Zill's Advanced Engineering Mathematics, which is a thorough introduction to more advanced topics in mathematics (linear algebra, complex analysis, real analysis, partial differential equations, and ordinary differential equations). The topics in this book are essential — once you master them, you'll have all the math you need to know in order to understand undergraduate physics. You can also buy the (cheaper) 4th and 5th editions.

4. Modern Physics

What It's All About

The fourth physics class that most undergraduates take is usually called "Modern Physics", and it's an introduction to topics in physics that will be taught in greater detail later in the undergraduate physics curriculum. If you plan to study the advanced topics on their own, it's fine to skip this class, but covering these topics now in your independent studies will allow you to grasp the advanced topics that you hear so much about and that probably got you into physics in the first place. This is where you'll learn the basics of thermodynamics, relativity, quantum mechanics, atomic physics, nuclear physics, particle physics, and cosmology.

The Best Textbooks to Use

• University Physics with Modern Physics by Young and Freedman (essential). Work through the "Thermodynamics" section (chapters 17-20 in my edition of the book), and the "Modern Physics" section (chapters 37-44). You can find inexpensive copies of the 12th edition, the 13th edition, and the 14th edition that contain the same material.

The Math You'll Need To Learn Alongside It

Continue working through Zill's Advanced Engineering Mathematics. Once you have mastered all of the topics in this book, you'll have all the math you need to know in order to understand undergraduate physics.

5. Classical Mechanics

What It's All About

This is where you’ll really learn classical mechanics, which you were introduced to in the very first course (Introduction to Mechanics). You'll study the topics in much greater depth, and learn how to use different mathematical formalisms of classical mechanics (the Lagrangian formalism and the Hamiltonian formalism) to solve problems in mechanics.

The Best Textbooks to Use

• Taylor's Classical Mechanics (essential). This is a fantastic introduction to classical mechanics.
• Morin's Introduction to Classical Mechanics with Problems and Solutions (supplement). Morin's book is a good supplement to Taylor's, and contains some great problems to work through.
• Problems and Solutions in Introductory Mechanics by Morin (supplement). Even more great problems (with solutions) to work through, and contains some great problem-solving strategies.

The Math You'll Need To Learn Alongside It

If you haven't finished working through Zill by now, you should master the topics in it by the time you finish studying classical mechanics.

6. Electrodynamics

What It's All About

Earlier, you learned about electrostatics: the study of static (non-moving) electricity and magnetism. By now, you know the mathematics to understand electrodynamics, which encompasses everything about classical electricity and magnetism. You'll cover electrostatics again, then learn about Laplace's equation, multipole expansions, polarization, dielectrics, the Lorentz Force Law, the Biot-Savart Law, magnetic vector potential, electromotive force, electromagnetic induction, Maxwell's equations, electromagnetic waves and radiation, and special relativity.

The Best Textbooks to Use

• Griffith's Introduction to Electrodynamics (essential). This is the book on undergraduate electrodynamics and one of the very best physics textbooks ever written. Make sure you work through every single problem in the book.
• Div, Grad, Curl and All That by Schey (supplement). This is a short textbook on vector calculus that is very helpful when trying to work with vectors in electrodynamics.
• A Student's Guide to Maxwell's Equations by Fleisch (supplement). Maxwell's equations are essential in understanding electrodynamics, and this book is the best supplement on the topic.

7. Quantum Mechanics

What It's All About

By this point, you're ready to really dive into the fundamentals of quantum mechanics and its applications — one of the most beautiful, interesting, and thought-provoking topics in all of physics. You'll learn to see the world in a completely new way. You'll learn about the wave function, the Schrodinger equation, perturbation theory, the variational principle, the WKB Approximation, the adiabatic approximation, and scattering.

The Best Textbooks to Use

• Griffith's Introduction to Quantum Mechanics (essential). This is, without a doubt, the book on undergraduate quantum mechanics, written by the same Griffiths who wrote the Introduction to Electrodynamics. It's written in the same concise and beautiful style, and every single problem is worth solving.

8. Thermodynamics and Statistical Mechanics

What It's All About

Thermodynamics is the field of physics concerned with kinetics (dynamics) related to heat and energy, while statistical mechanics is all about the microscopic principles that underlie the Laws of Thermodynamics. This is where you'll learn about the laws of thermodynamics, entropy, the canonical ensemble, Maxwell distributions, Planck's distribution, Fermi-Dirac statistics, Bose-Einstein statistics, and phase transitions.

By the time you've finished this topic, you'll have mastered all of the fundamentals of undergraduate physics!

The Best Textbooks to Use

• Schroeder’s An Introduction to Thermal Physics (essential). A very thorough and comprehensive introduction to thermodynamics and statistical mechanics; contains very clear and straightforward explanations and examples.
• Introductory Statistical Mechanics by Bowley and Sanchez (supplement). A good second text to have on hand to reference.

9. Undergraduate Electives

What They’re All About

Now that you understand all of the fundamentals of undergraduate physics, you have a solid foundation and can study more advanced and specialized topics, including (but not limited to) astronomy, astrophysics, biophysics, cosmology, electronics, optics, particle physics, and string theory.

The Best Textbooks to Use

• Astronomy: The Cosmic Perspective. A wonderful introduction to astronomy, accessible to anyone who is just beginning to study physics.
• Astrophysics: An Introduction to Modern Astrophysics by Carroll and Ostlie. A comprehensive introduction to modern astrophysics.
• Biophysics: Biophysics: An Introduction by Glaser. A solid introduction to the principles of biophysics.
• Cosmology: Ryden's Introduction to Cosmology. My absolute favorite introductory cosmology book.
• Electronics: Basic Electronics for Scientists and Engineers by Eggleston. Accessible to anyone who has worked through the basics of electrodynamics.
• Optics. Optics by Hecht. The classic (and truly amazing) optics textbook.
• Particle Physics: Griffith's Introduction to Elementary Particles. Written by the same Griffith who gave us the Introduction to Electrodynamics and Introduction to Quantum Mechanics, this book is the perfect introduction to the fundamentals of particle physics and is a joy to work through.
• String Theory. A First Course in String Theory by Zwiebach. The essential introduction to string theory.

Graduate Physics

Overview

Graduate-level physics requires mastery of every topic within the undergraduate physics curriculum above as a prerequisite.

The graduate physics core is comprised of:

1. Mathematical Methods in Physics
2. Electrodynamics
3. Quantum Mechanics
4. Statistical Mechanics
5. General Relativity
6. Quantum Field Theory
7. Graduate Electives

I'll cover each of these in the sections below. (Note: many graduate students are required to take a course in classical mechanics as part of the graduate core, but if you've mastered the material in undergraduate classical mechanics there is no need for this).

1. Mathematical Methods in Physics

What It's All About

Studying electrodynamics, quantum mechanics, and stat mech in more depth at the graduate level requires a greater level of mathematical rigor. To prepare, you'll need to learn the following in greater detail: Fourier analysis, tensors, ODEs, PDEs, real analysis, complex analysis, algebra, and group theory (to name a few).

The Best Textbooks To Use

• Mathematical Methods for Physicists by Arfken, Weber, and Harris (essential). This book covers the essentials of everything you'll need to know for the mathematical rigor demanded by the graduate core.
• Tolstov's Fourier Series (supplement). The best book on Fourier Analysis ever written. Complements the main text very well.
• Complex Variables by Fisher (supplement). Amazing overview of complex analysis. Can be used along with Needham's Visual Complex Analysis to supplement the main text.
• Zee's Group Theory in a Nutshell for Physicists (supplement). A brilliant introduction to group theory for physicists.

2. Graduate Electrodynamics

What It's All About

Graduate-level electrodynamics covers the same topics as undergraduate electrodynamics but with greater mathematical rigor.

The Best Textbooks To Use

• Classical Electrodynamics by Jackson (essential). This is the bible of classical electrodynamics, and everyone who works through either loves it or hates it (I loved it). If you can master everything in this book and work through a decent selection of the problems, you'll have mastered electrodynamics.

3. Graduate Quantum Mechanics

What It's All About

Graduate quantum mechanics is far more advanced than what you learned at the undergraduate level. Here you'll learn, in great depth, all there is to know about quantum mechanics, including quantum dynamics (the Schrodinger equation, the Heisenberg picture, propagators, and Feynman path integrals), angular momentum, symmetries and conservation laws of the quantum world, perturbation theory, scattering theory, relativistic quantum mechanics, decoherence, and interpretations of quantum mechanics (the Copenhagen vs. Many-Worlds interpretations).

The Best Textbooks To Use

• Sakurai's Modern Quantum Mechanics (essential). This is my favorite textbook on quantum mechanics, and the one I used to learn quantum mechanics for the very first time. It's a wonderful, elegant, simple book with clear and understandable problems. Try to work through all of the problems — if you do, you'll understand quantum mechanics very well.
• Quantum Mechanics and Path Integrals by Feynman (essential). Sakurai's coverage of Feynman's Path Integral formalism of quantum mechanics doesn't do it justice. Working through this text (written by Feynman himself) is not only useful, but incredibly fun.
• The Principles of Quantum Mechanics by Dirac (supplement). Dirac was one of the founding fathers of quantum mechanics and quantum field theory. This book is important historically, and also will open your eyes to the need for quantum field theory.
• Principles of Quantum Mechanics by Shankar (supplement). A great supplement to Sakurai for more information about each topic. A bit too dense to serve as a primary text, it works best as an addition or reference.
• Decoherence and the Appearance of a Classical World in Quantum Theory (supplement). This book is very dense and you may not understand all of it even after working through Sakurai, but understanding decoherence is essential to understanding how the classical world arises from the quantum.
• The Everett Interpretation of Quantum Mechanics: Collected Works 1955-1980 (supplement). Very few books have been written on interpretations of quantum mechanics, and reading through this volume helps to understand the limitations of our interpretations as well as the complexities and details of Everett's Many-Worlds interpretation.

4. Graduate Statistical Mechanics

What It's All About

Now that you have a more solid mathematical background and understand all of the fundamentals of quantum mechanics, it's time to approach graduate-level statistical mechanics. You'll revisit the Laws of Thermodynamics, and then pick up from where you left off in undergraduate statistical mechanics.

The Best Textbooks To Use

• Statistical Mechanics by Pathria and Beale (essential). This book is, admittedly, a bit frustrating, but it's worth suffering through because if you make it all the way to the end and work through the majority of the problems, you'll know stat mech like the back of your hand.
• Huang's Statistical Mechanics (supplementary). This is a great book to supplement the main text — is a good bridge between undergraduate stat mech and Pathria.

5. General Relativity

What It's All About

By now you'll have a very deep understanding of Einstein's special theory of relativity, but, as you may have noticed, general relativity (GR) — the theory of gravitation — hasn't yet been mentioned. That's because GR is a mathematically demanding topic — not only do you need to know all of the math you've learned so far, but you'll need to learn differential geometry in order to make sense of how gravity works. Here, you'll revisit special relativity and the intricacies of spacetime, then learn the basics of differential geometry, how to deal with curvature, the essentials of gravitation, how black holes work, and the basics of cosmology.

The Best Textbooks To Use

• Spacetime and Geometry by Carroll (essential). This is the book on general relativity, and Carroll does a phenomenal job of introducing the essentials of differential geometry and general relativity.
• Einstein Gravity in a Nutshell by Zee (supplement). A great, accessible overview.
• Wald's General Relativity (supplement). Wald's book is a very abstract, high-level overview of general relativity, and makes a great supplement to Carroll's book. Go to Carroll for the overview, look it up in Wald for the high-level abstractions, and then look in the apple book for the dirty details.
• Gravitation by Misner, Thorne, and Wheeler (supplement). Also known as the "apple book" thanks to the apple gracing its cover, this book goes into the nitty-gritty details of general relativity in ways that no other book does.
• Weinberg's Gravitation and Cosmology (supplement). Weinberg is one of those rare physicists who has not only been at the forefront of every major field in physics, but has written about each of them as well. His books tend to be inaccessible to beginners, however, and this book is no exception. It does make a good supplementary reading, but I'd advise reading it after you've worked through the rest.
• Differential Geometry of Curves and Surfaces by Manfredo P. do Carmo (supplement). The classic differential geometry textbook; may be useful to help you wrap your head around differential geometry.

6. Quantum Field Theory

What It's All About

Quantum Field Theory (QFT) is the heart of all modern high-energy physics: the Standard Model of particle physics is a QFT. The whole idea behind QFT is that we are doing quantum mechanics on classical fields, and it works remarkably well. Along with GR, QFT will be the most challenging part of your physics education, but perhaps the most rewarding (I know it was extraordinarily rewarding for me!). It may take many, many years to master. You'll learn about how to quantize fields, Feynman diagrams, quantum electrodynamics (QED), renormalization, non-Abelian gauge theories, quantum chromodynamics (QCD), the Higgs mechanism, the Glashow-Weinberg-Salam theory of electroweak interactions, the symmetries of particle physics, and spontaneous symmetry breaking.

The Best Textbooks To Use

• Zee's Quantum Field Theory in a Nutshell (essential). This is my favorite physics book of all time, and the most beautiful introduction to QFT ever written. You'll walk away understanding the basics of QFT and with a deep understanding of the fundamental nature of the universe.
• An Introduction to Quantum Field Theory by Peskin and Schroeder (essential). This is the bible of QFT, but its far too terse and encyclopedic to work through on its own and must be studied alongside Zee. Covers everything you could possibly want to know about QFT. Try to work through the problems, but be aware that mastery of QFT will take a very, very long time.
• Weinberg's The Quantum Theory of Fields, Volume 1 (supplement). Another great volume by Weinberg, who was one of the most important physicists in the history of particle physics. This book should be used only as a supplement, and preferably not read until Zee and Peskin and Schroeder have been completed. It's not a book to learn from, but one to gain additional understanding of QFT through after you've mastered all of the basics.
• Lie Algebras in Particle Physics by Georgi (supplement). This dives into the details of Lie Algebras in QFT.

7. Graduate Electives

What They’re All About

The graduate curriculum can be split into several categories: (i) the core courses, (ii) specialized coursework and graduate electives, and (iii) research. Graduate students typically take the core courses first, which focus on the same topics covered in undergraduate courses but in much greater depth and with far more mathematical rigor. Students then choose more specialized courses and electives depending on their area of research in physics, including (but not limited to) condensed matter physics, cosmology, electronics, optics, particle physics, quantum computing, solid-state physics, and string theory.

The Best Textbooks to Use

• Condensed Matter Physics: Lubensky’s Principles of Condensed Matter Physics. A modern, comprehensive textbook. Fairly advanced, and is easier to understand after completing the graduate core and working through something like Ashcroft and Mermin.
• Cosmology: Mark Trodden and Sean Carroll’s TASI Lectures: Introduction to Cosmology. Supplement with Steven Weinberg’s Cosmology.
• Electronics: The Art of Electronics by Horowitz and Hill. The best electronics textbook there is, period.
• Optics: Optics by Hecht. The classic optics textbook.
• Particle Physics: Quarks and Leptons by Halzen and Martin. Wonderful overview that’s fun to read and work through. Supplement this with Modern Particle Physics by Mark Thomson, which is up-to-date on contemporary discoveries like the Higgs.
• Quantum Computing: Quantum Computation and Quantum Information by Michael A. Nielsen and Isaac L. Chuang. Also known as “Mike and Ike,” this is the standard introduction to quantum information and computation.
• Solid-State Physics: Solid-State Physics by Ashcroft and Mermin. The classic introductory solid-state textbook. Supplement with Introduction to Solid State Physics by Kittel.
• String Theory: String Theory: Volume 1, An Introduction to the Bosonic String and String Theory: Volume 2, Superstring Theory and Beyond, by the late Joe Polchinski; and String Theory and M-Theory: A Modern Introduction. I found it really enjoyable to pair Polchinski’s books with Becker Becker Schwarz when I was learning string theory — they complement each other well.

In a Brooklyn warehouse, a man handed me a piece of paper that was a running computer program.

Every useful company stands on rails that were once somebody’s stubbornly useless research. I invest in useful for a living. This essay is about the stage before useful, who works on it, and who pays for it, so that the next generation of useful companies has something to stand on. At Motive Force I back both stages. They need each other.

In June I stood in a warehouse in Brooklyn while a man handed me a piece of paper that was a running computer program.

A printout would have been a picture of a program. This was the program itself. He set it on the table and the system executed it. Then he connected a keyboard to the paper, typed a line of code, hit save, and the paper turned green. He unplugged the keyboard and the paper kept running, glowing on the table like it had always known how.

A few feet away, an animation system was cycling through hand drawn frames. He gave me a marker and I drew a bunny, frame by frame, and watched my drawings come alive in real time on the table. Then we made music by laying cards down between us, each card a track. I heard myself say a sentence I did not plan to say: “I don’t need the monitor anymore.” For the first time I was programming with my whole body, collaborating with another person in the same room, with almost no distance between the idea and the thing. It was the most human programming I have ever done.

The system is called Folk Computer. It’s an open source physical computing system built by Omar Rizwan and Andrés Cuervo, two researchers who worked at Dynamicland, Bret Victor’s lab in Oakland. Cameras on the ceiling watch the room. Projectors paint onto every surface. Small tags identify each piece of paper, and each piece of paper is a program. There are no pixels inside the system; every coordinate is in meters, mapped to where things sit in the room. You stop staring into a rectangle. The computer is the room, and you program it together with other people, standing up, talking, drawing, moving paper around.

I have spent my career inside enterprise software, decomposing how work gets done. I know what it looks like when someone is optimizing an existing paradigm. This was someone asking whether the desktop metaphor, the screen, the cubicle, the solitary body hunched toward a rectangle, was a fifty year detour rather than a destination.

How I got there

A week earlier I had lunch with my friend JP, who was visiting San Francisco. The Bay Area, I told him, has become a monoculture. Everyone is building the same thing, funded by the same people, using the same words. Where are the independent thinkers? I want the Xerox PARC vibes back, the people who work on questions instead of markets.

JP didn’t argue. He said: they exist, but not here. Or rather, they exist here too, but scattered, one by one, never together. And then he said a name: Folk Computer. In New York.

I happened to be flying to New York days later. I was going for something almost comically institutional, which turns out to be the other half of this story.

The oldest club in computing

I was in New York to volunteer. I sit on the Professional Development Committee of the ACM, the Association for Computing Machinery, the world’s largest and oldest computing society. It was founded in 1947, back when computing was a curiosity shared by a few hundred people, before anyone could make a career of it. The organization’s stated purpose was to advance “the new machinery for computing, reasoning, and other handling of information.” Reasoning, in 1947. Joining an association about computers was itself an act of independent thinking. No one joined for money. They joined out of conviction that something interesting was going to happen.

Nearly eighty years later, ACM has over 100,000 members and gives out the Turing Award, computing’s Nobel. When our committee reviewed what members are learning right now, the picture was striking: the entire field is studying the same topic. The most read titles and the most searched terms are all about agents. The learning curves of a whole discipline have converged into one line.

I am not against that line. I invest in it. My whole firm is built on the thesis that autonomous execution needs deterministic infrastructure, and the convergence is part of why the opportunity is real. But convergence has a cost: no one is left standing off to the side asking the strange question. The next paradigm comes from the people the curve forgot.

I carried the institutional memory of computing’s oldest society into that warehouse, and watched its youngest incarnation run on paper.

The lineage

Folk Computer did not come from nowhere. It is the current end of a thread that runs back through the entire history of the field.

It starts with Alan Kay at Xerox PARC in the 1970s, asking what computing would look like as a medium for thought rather than a machine for calculation, and inventing, along the way, most of what you are using to read this. Kay spent the rest of his career trying to rebuild the conditions that made PARC possible: total freedom, long time horizons, no product pressure. In 2013 he tried again. He recruited Bret Victor, Vi Hart, and Dan Ingalls as principal investigators of a new lab in San Francisco called CDG, the Communications Design Group.

CDG was funded by SAP, and by Vishal Sikka in particular, SAP’s CTO at the time, who believed in Kay’s vision and had the resources to back it. I joined SAP in Germany as a working student during my Masters and stayed seven years, in the CTO’s own organization. In all that time I never heard the name CDG once, even though being part of it would have made my years there far richer. The lab was invisible on purpose. The name was chosen because it was generic enough to be forgotten; the researchers had watched what attention does to this kind of work, and they wanted none of it.

Inside, they practiced what they called deep work with an intensity that reorganized even their manners. Nobody said hello in the morning. Nobody said goodbye at night. The silence was a form of trust, an agreement never to interrupt each other’s decades-long thoughts. Their prototypes were built, in their own words, against usefulness. Usefulness, they had learned, is a trap: the moment a prototype becomes useful, its makers start answering to present users and stop pointing at the future. And Victor himself, in the talk that made him famous, described his motivation in words you never hear in a technical field. When he sees creators constrained by their tools, he sees an injustice. “Not opportunity, but responsibility.”

Vishal left SAP in 2014, and the lab lost its champion. The researchers migrated to HARC under Y Combinator Research; when that ended too, Victor’s group took over the Oakland space and became Dynamicland, a nonprofit where the building itself is the computer. Dynamicland spawned the next generation: Omar and Andrés, who took what they learned and made one decisive pivot. They built it open source.

That pivot matters more than it sounds. The recurring criticism of this whole lineage, and I have felt it myself, is that you see the demos and cannot do anything with them. The knowledge stays locked in one building, open to the few who can visit. Folk Computer inverts that. The code is on GitHub. People around the world have set up their own systems. Strangers contribute. A friend of theirs built a music sequencer out of physical cards; flip a card, change a track. The thread that ran through PARC and CDG and Dynamicland is, for the first time, something you can pull on from your own home.

Who pays for this

I allocate capital for a living, so I pay attention to who funded this lineage. Xerox funded PARC out of an instinct, give brilliant people machines and freedom and something interesting will happen, then failed to capture most of the value PARC created. CDG existed because one executive at a German enterprise software company believed. Dynamicland ran as a nonprofit on donations, and Omar told me something that stuck: the early patrons of this work tended to come from odd backgrounds, art, music, family money, because the tech people were all too busy being excited about their own thing. It’s the same reason Stripe Press exists. Patrick Collison runs a payments company and yet republishes the foundational texts of this exact tradition, because underneath the CEO there is a person who cannot leave these ideas alone.

Paradigm work has always run on patrons. A new paradigm is useless at the beginning, by definition, so markets have nothing to price. The first personal computers were toys. So was the early internet. The people who fund this stage are buying a position in the future before anyone can price it.

My flight home was delayed, so I wandered into Mercer Labs, the museum of art and technology near the World Trade Center. Twenty six projectors, sound that moves through space, rooms that dissolve around you. It transported me, and it clarified something. Mercer is the consumption version of this future: you stand inside someone else’s computation and watch. Brooklyn was the agency version, the one that hands you new capabilities: you pick up a marker and the room becomes yours. Both will exist. Only one of them changes who gets to build.

A Request for Independent Thinkers

Y Combinator publishes a Request for Startups: a list of ideas they wish someone would build. It’s a good list. It also assumes the bottleneck is ideas, and that the future can be specified in advance.

Nothing in this lineage worked that way. Nobody could have written “interactive paper computing” on a request list in 2013. It exists because a specific kind of person pulled on a specific thread for over a decade, through four institutional deaths. For paradigm-level work, you cannot spec the what. You can only recognize the who.

Here is mine, inverted: a Request for Independent Thinkers. I am looking for the person who

• has been obsessed with one unfashionable question for years, and can tell you why the obvious approach is wrong
• builds in the open, or wants to, because they would rather the idea live than own it
• measures progress in decades, not quarters and decks
• is allergic to hype, and probably lives, physically or intellectually, some distance from it
• makes you say a sentence you did not plan to say

If this is you, I want to meet you. This is separate from investing; most of this work is pre company, and it should be. Sometimes the right instrument is a check, sometimes a grant, sometimes a contract, sometimes a room and an introduction. Xerox never recognized the value of what came out of PARC, and odds are the people around you do not recognize what you are building either. I read that the way Victor does, as an injustice. My firm is small, but I can help: an introduction to someone who can fund it, or distribution for what you see, so others can join you and build on it.

If you know this person, send them this.

And if you are someone with resources who has been looking for a way into the future that isn’t another agent startup: start with Folk Computer. Read what it can do. Set one up. Sponsor them, commission a physical demo, or run a pilot.

I went to Manhattan for the oldest institution in computing and found its founding spirit alive in Brooklyn, in its newest form. Both are running the same eighty year old bet: gather the people who cannot stop asking, and something interesting will happen.

I’m assembling them now. If you’re one of them, my door is open.

---

Thanks to Omar Rizwan for the demo and for reviewing a draft of this essay, and to JP for the tip. If you want to be in the room when I bring these people together, reply to this email.

LARP pairs you with another founder. You send them $10,000. They send you $10,000 right back. You've both now booked $10,000 in revenue. The books balance. Cash never moves. Everybody's a rocketship.

Global LARP volume this year

$0

$0 of it real.

Trusted by 400+ finance and accounting teams

VerithorNorthbankCadenza Systems Halyard & VaneOrlick LabsSteelportMerridian

99.98%

Settlement uptime

<400ms

Median recognition latency

SOC 2 Type II

Audited annually

Three steps to a rounding error the size of a Series B.

No product required. No customers required. No, seriously — no customers.

01 — Match with a peer

Any founder with a bank account and a dream.

You both agree on a number. Bigger is better. The number is the entire product.

02 — Wire it in a circle

You → them → you. Or don't. Honestly, don't.

Each leg counts as revenue for the receiver. Two legs, two "customers," zero net cash.

03 — Recognize it forever

Annualize. Then annualize the annualization.

$10k/mo becomes $120k ARR. Loop weekly and watch a single hundred-dollar bill fund a whole deck.

The catch

There isn't one. That's the catch.

The number in the pitch is real. Whether it means anything is a philosophy question, not an accounting one.

The trillion-dollar version books about as much new demand as yours did.

Same shape as your ledger — capital, chips, and cloud credits circling a handful of companies, each leg counted as revenue somewhere. Tap a company to see the actual reported deals. Every figure is real and sourced.

capital flowing chips / compute flowing back tap a node

To be clear: every deal here is legal, publicly announced, and defended by the people in it — Anthropic CEO Dario Amodei called the structure "nothing inappropriate in principle." Critics compare the pattern to 1990s dot-com vendor financing and warn it can inflate the appearance of demand. As Bloomberg puts it, a circular deal is legally different from a fraudulent "round-trip" — regulators' term for sham trades with no economic substance designed to inflate results. LARP is a joke about the round-trip. This is the legal cousin it rhymes with.

Book some revenue.

Enter a friend's startup and a number. Hit execute. Watch your ARR launch while your cash sits exactly where it started: nowhere.

Your annual recurring revenue

$0

NET CASH MOVED: $0

You — Bird Capital Holdings

Debit / Credit journal

No entries yet. Suspiciously honest of you.

Revenue recognized$0

Synergos AI

Debit / Credit journal

Also waiting to get rich doing nothing.

Revenue recognized$0

$0

ARR

0

Loops closed

—

MoM growth

0.0x

Burn multiple

Chart shows revenue recognized. It does not, and cannot, show cash — because there isn't any.

Finance teams close faster on LARP.

Controllers and CFOs use LARP to remove settlement friction from the revenue cycle.

"We recognized 340% year-over-year revenue growth without any change to our cash position. Our auditors had no questions. The journal entries were already there."

DM

D. Mercer

VP Finance, Cadenza Systems

"Before LARP, growth was constrained by whether customers actually paid us. That's no longer a bottleneck we think about."

RO

R. Oduya

Controller, Northbank

"We closed the quarter in four days. Every entry reconciles perfectly, because every entry has a matching entry."

SV

S. Valko

CFO, Halyard & Vane

Settle programmatically.

A single endpoint posts matched entries to both counterparties.

curl -X POST https://api.larp.co/v1/settlements \ -H "Authorization: Bearer $LARP_API_KEY" \ -d counterparty_id=cp_8f2a91 \ -d amount=1000000 \ -d currency=usd \ -d recognition=monthly

{ "id": "stl_4b1e77", "status": "settled", "amount": 1000000, "recognized_by": ["acct_self", "cp_8f2a91"], "net_capital_movement": 0, "journal_entries": 4 }

Both counterparties recognize the full amount. See Recognition → Symmetry.

The legality question.

Is this legal?

Yes. LARP facilitates mutual service agreements between consenting, verified business entities. Each agreement specifies genuine deliverables and genuine consideration, and each party independently recognizes revenue under ASC 606 upon satisfaction of its performance obligation. Bilateral commercial arrangements — including reciprocal vendor relationships, strategic partnerships, and vendor financing — are longstanding and lawful features of commercial practice, and are widely used by public companies today.

Customers are solely responsible for determining whether their use of the platform complies with applicable accounting standards, disclosure obligations, and securities law. LARP does not provide accounting, legal, or tax advice. Our platform records what our customers instruct it to record.

How is this different from round-tripping?

Round-tripping refers to sham transactions with no economic substance, entered into for the purpose of inflating reported results. LARP requires that all agreements specify genuine deliverables. Determining whether a given arrangement has economic substance is the responsibility of the customer and its auditors.

You literally cannot pay us. That's the whole point.

Charging you would create real revenue, which would violate our principles.

Bootstrapper

$0

/ forever

• Loops up to $10k
• One imaginary customer
• Community-tier delusion

Growth ★

$0

/ still forever

• Unlimited loops
• Auto-generated board decks
• "Up and to the right" guarantee
• Annualize the annualization

Enterprise

Call us

/ we won't pick up

• Multi-party loop rings
• A very relaxed auditor
• Plausible deniability add-on

Actually — you can pay me.

The pricing section is a bit. This one isn't. If the joke earned a real dollar from you, here's where it goes.

GIFT · NOT A SECURITY

No equity. No revenue share. No pro-rata on the next round. No round. You are tipping a joke — that is the entire transaction, and the entire thing you get in return.

Or just email me — [email protected]. Say thanks, argue with the disclaimer, or tell me about the actual company you're building. That's the address.

Programmable pocket device for makers, pentesters and geeks

ESP32-P4 + C5, an AMOLED touchscreen, wireless, sensors and real I/O in something that fits in your hand. You write the code, and it becomes whatever you need.

Skip the setup

Most projects die in the setup: a screen, buttons, power and sensors to wire up before you can even begin. Kode Dot hands you a finished platform, so you start with your idea instead of rebuilding the basics.

All the key hardware, built in

Dual MCU (ESP32 P4 + C5), a crisp AMOLED touchscreen and an SD card slot for your apps. Charge it, flash it and play. Nothing to assemble.

Extend it with GPIO

Sixteen programmable pins. Plug in cables and wire up sensors, motors or your own boards. The Kode Dot grows with your projects.

Snap on a new superpower

Build, use and share apps with the community.

Browse what the community ships: games, tools and toys. Run them on your Kode Dot.

SnakeInvadersDoomDiceServoControlBubbleLevelAirMouseCuteAssistant GPT

Kode Dot running a community app

Build with the tools you already know

ArduinoEspressifPlatformIO

let's play, let's kode.

Kode Dot

• Wi-Fi
• BLE
• LED
• Speaker
• IR
• NFC
• Mic

Interacts with everything.

Wi-Fi, Bluetooth LE, infrared and NFC, plus a speaker, a mic and a programmable LED. Out of the box, the Kode Dot talks to your network, your gadgets and the world around it.

Small device. Big toolbox.

Every chip, sensor and port the Kode Dot packs in.

ESP32-P4 + C5

The P4 runs everything; the C5 does the wireless.

2.13″ AMOLED display

A crisp 502×410 touch panel.

32 MB PSRAM · 32 MB flash

Real memory headroom for real apps.

NFC · RFID · IR

Read and emulate tags, cards and remotes.

CO5300 display driver

Drives the AMOLED over MIPI-DSI, smooth and fast.

CST820 touch

Quick, accurate capacitive touch.

9-axis IMU

6-axis LSM6DSV plus a LIS2MDL compass: a full 9-axis motion stack.

ST25R3916B NFC

Read, write and emulate 13.56 MHz tags.

125 kHz RFID

Read and emulate cards through a discrete analog front-end.

IR transceiver

Blast and capture infrared. Learn any remote.

microSD (SD/MMC)

Removable storage for data and big apps.

Speaker + mic

ES8311 codec and NS4150B class-D amp drive the speaker, plus an on-board mic.

Haptic vibration motor

Crisp vibration feedback from an AW86233 LRA driver.

BQ25896 PMIC

USB-C charging with power path and OTG.

CW2217 fuel gauge

Knows exactly how much battery is left.

LiPo battery

Power your projects. Capacity TBD.

Battery-backed RTC

Keeps real time on the always-on domain.

USB-C + JTAG

Flash, charge, debug and USB OTG, all over one port.

Magnetic pogo connector

Charge in or power out, plus two programmable GPIOs.

20-pin GPIO header

14 programmable GPIOs, plus 5 V and 3.3 V rails up to 2 A each.

D-pad + 2 buttons

A 4-button D-pad and two extra buttons for games and menus.

KTD2026 RGB LED

An addressable status light to play with.

Backed by 16,000 makers.

Kode Dot started as a Kickstarter dream, and 16,000 backers made it real. From our workshop to your hands, thank you for believing in it. This is only the beginning.

Manuel Quero and Luismi Collado, Kode's founders, in the factory

Manuel Quero and Luismi Collado, makers and founders of Kode.

The penultimate paper on paint(1) and the 9front art machine.

0 Questions.

What is How to draw?
This is a document that will teach you how to be just like me, drawing on computers running an operating system you know nothing about.

Who might How to draw appeal to?

• perverts
• robots
• witches

Who will How to draw not appeal to?

• artists
• atheists
• iconoclasts

Why has How to draw been submitted to OCC 2026?
My 9front art machine is an old computer. It was used to create this document and most of the visual attachments.

What's the tl;dr version of How to draw?
Click and drag.

How to get started with 9front?

• Go here
• Read the book

Before you scroll any further, it is strongly recommended that you first read Free Carrots #8: How to draw to familiarize yourself with the history and philosophy of drawing, and hardware and software options you might want to explore.

With that out of the way, this is:

1 How to draw

To draw you need two things. Something to draw with and something to draw on. The natural inclination might be to use a real device that you can touch with a pen and produce lines, but there are worse and less convenient ways to draw with 9front that you might prefer. While this document is written with a computer one can draw on in mind, most of it is applicable to any of the input methods below. Maybe you can think of new ones.

1.1 The Machine

1.1.1 A Computer

If you don't care about drawing on screens, you can learn How to draw on any computer running 9front.

1.1.2 Two in One

All in one. Canvas and brush - perhaps the ideal choice for those who like to draw on paper. Wacomized laptops with pens. Crack the screen open and draw on it. Here is a list of devices proven to work well for the purposes of How to draw:

• ThinkPad X41t
• Thinkpad X60t, X61t
• ThinkPad X380 Yoga
• ThinkPad X1 Yoga 3rd Gen
• ThinkPad X1 Titanium Yoga

There's probably a million other 2in1 9front art machines that work well, you just have to find them, and preferably tell someone you did.

1.2 The Input

1.2.1 Mouse

Mouse drawing is a very old technique. Favored for its compatibility with any computer that has a mouse.

1.2.2 Finger

Touching the screen emulates left mouse clicks. There's no way to emulate any other, so a mouse needs to be kept nearby. Some people's entire gimmick depends on the fact that they finger paint their art. If you have a device that allows it, you can finger paint with 9front.

1.2.3 Tablet

External tablets with screens will (probably) not work with 9front.

External tablets without screens might work. Similarly to 2in1 drawing computers, external tablet pens with buttons can potentially simulate all three mouse clicks. I've seen it.

Of the three tablets that I personally tried, the one to recommend is GAOMON S620

pic

Bought specifically for 9front, I ended up drawing the bulk of early Techno-Mage with it in OpenBSD. It still works great in 9front. Plug n play. Not so much in OpenBSD anymore.

The other two:

• Acts like a touchpad (relative positioning) Wacom CTL-672
• Does not work Wacom CTL-490

Some more information on tablets: [fqa] 3.2.4 - Tablet Digitizers

1.2.4 Keyboard

You can't really draw with a keyboard (though you can write pictures), but you can't get away without using it either. For tablet computers, inaccessible physical keyboards, and other obscure setups, there is bitsy/keyboard, an on-screen keyboard. It has to be started through rio with the -k option:

% rio -k 'bitsy/keyboard -n'

pic

1.2.5 Drawterm / vnc

Drawterm into a distant and/or virtual 9front computer, use any of the aforementioned methods and devices, and a million more. You'll probably have a bad time, but the size of your tool box will grow drastically. You could finger paint with 9front from your Android telephone, mouse draw from any Linux and MacOS, use all the input devices that don't work with 9front from Windows,... Any combination of these will impress your hypothetical employer.

pic

drawterm.9front.org

1.3 The Medium

All image operations, drawing, cropping,... are performed on files in 9front's internal image(6) format. This is the default for everything this document works with. For producing pictures this is irrelevant and you never have to think about it. It is only after you want to share your creation with the wider world that you will want to convert it to a different format.

pic

I usually name my 9front picture files file.pic. You can call them whatever you want.

2 paint(1)

pic

While there is a fairly large selection of drawing software for 9front, this document concerns itself with paint(1) only, the original 9front drawing program. Not many know where it came from. Some say it manifested itself out of nowhere. Some blame cinap. Whatever the myth of origin, today paint(1) is known as one of the 7 princes of hell.

paint

2.1 Getting Startled

Forget what you know about digital art. Forget what you know about drawing.

As you read on, you will realize that working with paint(1) is much closer to drawing with physical paper, ink, and colors than any other digital drawing program. It's like analog art, but not really.

Like with everything, it is advised you read the documentation of the programs mentioned in this paper. The functions and options listed and described here aim to explain to the reader How to draw, they only cover what is potentially useful for achieving that goal.

2.1.1 Pen and Mouse

Tablet and computer pens and their buttons only simulate mouse inputs. This document will only reference mouse operations. It is up to you to learn how these are performed with your pen.

Hovering about simulates mouse movement, touching the surface simulates a left mouse click (or hold). In the ideal world a pen has two extra buttons. One for middle click, one for right click. In the less than ideal world, one of the buttons emulates either middle or right click, and the other button puts the pen into a different device mode (this is usually used for mapping the button to a different tool) - in 9front, this might not do anything, or it might emulate the third otherwise missing mouse click. Your mileage may vary.

pic

If your pen only has one working button that emulates right click, you can simulate middle mouse click by holding shift and then holding the pen button. As an example, you will erase when holding the button, you will pan around when holding shift with the button.

For the most part, you will want to keep both keyboard and mouse nearby to perform the operations your pen cannot. If your pen can simulate all three mouse clicks, you may be satisfied with just a virtual keyboard (1.2.4) when using paint(1).

2.1.2 What paint(1) cannot do for you

No pressure sensitivity: paint(1) and 9front in general have no support for it. Yet.

No layers, no cut-n-paste: what you draw is what you get. This limitation and potential alleviation is explored below (2.4). You will benefit from approaching paint(1) as if it were a piece of paper.

2.1.3 paint(1) Keys

Save your picture: w - write file - press w and type the file name you want your picture saved as. Next time you press w, the last file name you put in will already be shown. To write repeatedly into the same file just press w and Enter. Do this often. Once you've saved your picture to a file, you can open it in page(1) or perform other image operations on it.

Open a picture: r - read file - press r and type the file name of a picture you want to open or reload. Like with w, once you read a file once, the file name will be shown in the prompt. r is useful for performing external image operations on the file you're currently drawing, and then reloading the modified file in paint(1).

Transform: | - transform the canvas by piping it through a command. The only time I use it is with rotate(1).

| rotate -u

Redirection: < command - perform some operation on a file and read it in paint(1). This will replace whatever currently exists on your canvas.

Open file glenda.pic with a 50 pixel black border

 < crop -i -50 glenda.pic

Open file glenda.pic (same as r, but does not replace the filename in the w/r prompt)

< cat glenda.pic

Redirection: > command - perform some operation on the current canvas and write it to a file.

Add a 50 pixel black border to the current canvas, rotate it by 90 degrees and write (save) it to file modified_glenda.pic

> crop -i -50 | rotate -r 90 > modified_glenda.pic

Make a backup of the current file. This will not change the pre-filled file name in w

> cat > backup_glenda.pic

2.2 Canvas

In paint(1)'s context, the word canvas is understood as the area (a rectangle) that contains your drawing.

When you start paint(1) you are greeted by a white window and a toolbar. Even though you won't be able to tell, you can pan around the endless white in any direction for all eternity. This is what an empty file looks like. It is only after you've drawn (or erased) your first pixel that the canvas is created.

paint(1) considers the farthest placed pixels as the edges of your canvas. It does not care how big your window is (erasing pixels still counts as placing pixels, this means that if you middle mouse somewhere in the aether, paint(1) will consider that part of your canvas).

paint(1) on the left, page(1) on the right:

pic

Notice how the canvas expands after arbitrary crop marks were drawn in the corners.

pic

2.2.1 Treat the initial window size of paint(1) as your canvas

It will prove benefitial to think ahead. Consider the paper metaphor - treat the arbitrary size of the paint(1) window you create as the size of your canvas.

pic

Start paint(1), draw some crop marks in the corners, start drawing. You will still pan around the canvas, nobody likes to draw at the window border, but this self-imposed limitation will give you a clear idea when to stop. After you're done you can crop off whatever you don't like.

If you need to produce a picture with exact dimensions, this is explored further down (3.5)

2.3 Tools

Selection of any tool is done by clicking the tool bar at the bottom with left mouse. Where applicable, key shortcuts are listed.

2.3.1 Colors

Colors are selected with left mouse. Right clicking any color in the toolbar prompts for a hexcode. This is how you can change your palette.

pic

paint(1) will not remember your palette after you close it. You will have to change the palette every time you open a new window. If you want to use the same palette on different drawings, keep your window open and use r.

If you plan to use more than 16 colors, you can create multiple paint(1) windows and jump between them, as opposed to changing the colors in a single one. Make two (or more) paint(1) windows and open the same picture file in both with r.

 r picture.pic

In the following picture example I used the fill tool to color in the letters "heel" in the right window. Then I pressed w and Enter. I moved to the left window and pressed r and Enter. Then I continued in the left window.

pic

This is not an overtly complicated solution, you just have to remember to write and read every time you move to a different window.

2.3.2 Brush

0-9, left mouse - select the desired brush size, click and drag to draw.

2.3.3 Fill

f, c, left mouse, middle mouse - the obvious function of the fill tool is to turn neigboring pixels of the same color a different color. This is done by selecting the tool and color, and left clicking somewhere.

pic

It is also used for changing the background color of your canvas. This can be achieved in two ways. Either middle click a color in the tool bar, or select the fill tool, select a color, and click outside the area of your drawing.

Importantly the set background color is what the eraser will turn everyting into.

pic

The above picture and the following steps explain how changing the background color does and does not modify your drawing and the current size of your canvas:

• 1. paint(1) starts (canvas is empty)
• 2. select fill tool and middle click purple color
• 3. all of paint(1)'s window is now purple (canvas is still empty)
• 4. select brush and black color
• 5. draw X anywhere - this now defines the size of the canvas (canvas grows to encompass the X)
• 6. select fill tool and green color
• 7. left click outside the (invisible) rectangle that encapsulates the X (the purple rectangle is the current size of the canvas)
• 8. the rectangle with X remains purple, everything outside of it is green (canvas size is the same since step 5.)
• 9. select brush and black color
• 10. draw O outside the purple rectangle (canvas size grows)
• 11. middle click yellow color
• 12. everything outside the rectangle that encapsulates O and X is yellow (the green rectangle is the current size of the canvas defined in step 10.)
• 13. select brush, black, and draw RECTANGLE inside the yellow (canvas grows)
• 14. ...

Simply put, to change the background color, use the fill tool and click anywhere outside the area that contains your drawing. Anything inside the area will not be affected. Changing the background color does not modify the size of the canvas. If you draw anywhere inside the background area, it stops being the background and becomes a part of the canvas.

Lastly, pressing c will remove everything and change the background to the selected color. This will turn your drawing and canvas into an empty file.

2.3.4 Eraser

pic

0-9, middle mouse - hold it and drag to replace everything underneath the cursor with the background color. Eraser size is equal to the currently selected brush.

2.3.5 Straight Line

Use a ruler.

pic

2.3.6 Circle

Use something flat and circular as a ruler.

pic

Or measure and predraw your circles with a compass on an onion skin paper, and trace the circles over it.

pic

2.3.7 Pan

right mouse - hold it and move around.

2.3.8 Zoom

-, + - zoom in and out. Note that you cannot zoom out past the original zoom level of paint(1). This is why treating the geometry of your window as the size of your canvas makes sense. You can hit Escape any time to see your full drawing. But if you're too adventurous, and your picture is larger than your window, there is a way to zoom out and see the whole thing (3.1).

2.3.9 Undo

u - push to undo the last continous segment that was drawn in the past tick. This is an unusual functionality compared to other drawing program where a single undo step erases everything that was drawn between holding down left mouse and letting go. Here, if you draw a single line for 10 seconds, you'll get about 20 undo steps.

2.3.10 Reset

Esc - reset zoom and center the canvas.

2.4 Faux Layers

If one is to approach drawing with 9front like drawing on paper, they might wish to incorporate the idea of sketching the picture first.

A good way to approach this is to select a color you will not otherwise use, in this example HotPink, sketch your picture and then draw over it with whatever color you want your linework to be:

pic

When you're done, you could use the fill tool or very precise erasure moves to get rid of the HotPink sketch layer. Depending on your sketch, this will probably take you longer than drawing the actual picture. It is instead recommended to use pico to remove a single color layer with a couple commands (3.6).

3 Image Operations

Now that you know How to draw, here are some extra things you can do to make your experience less jarring. Note that you can always open any output that went through crop(1), vcrop(1), resize(1) in paint(1) again.

3.1 page(1)

page(1) is a powerful document viewer. It is the de-facto standard for displaying image files of various formats, PDFs, ebooks, etc. When you're not displaying your drawing in paint(1), you will be looking at it through page(1).

pic

% page my_picture.pic

It is good practice to view the output of an image operation in page(1) before writing it to a file. Similarly to paint(1), you can press w to write whatever is displayed in page(1) to a file.

% rotate -l my_picture.pic | crop -i -10 | page

3.1.1 Viewport

You got too into the process and now your picture is too big to fit in the paint(1) window. Save your picture. Create a new window with page picture.file. Middle mouse it. fit width or fit height appropriately.

pic

Now whenever you save the picture you're drawing in paint(1), update the preview window by selecting one of the fit options.

3.2 vcrop(1), crop(1)

vcrop(1)

vcrop file.name

This is a graphical cropping utility. You can pan around with left mouse. Middle mouse selects the cropping tool, right mouse brings up a list of options - notably this is how you save your cropped picture.

Once the cropping tool is selected, the cursor will change to a cropping cursor. Hold left mouse and drag. You can cancel the crop selection with right mouse.

pic

Note that the anchor point of the cropping cursor is the tip of the black arrow, not its top-left corner. The picture will be cropped at the outside edge of the thick red rectangle (whatever is underneath the thick red line will be included in the cropped output).

vcrop(1) is very limited. It won't let you zoom, so if your desired cropage is larger than the window, it won't help you. Similarly if you need pixel-perfect precision for your crop, read on.

crop(1)

Remove or add strips of pixels.

pic

Crop 50 pixels from left and right.

% crop -x 50 mypic.pic > mypic_crop.pic

pic

Crop 10 pixels from the left, 15 pixels from the top, 20 pixels from the right and 6 pixels from the bottom:

% file mypic.pic
mypic.pic: Compressed plan 9 image or subfont, depth 32, size 313x306
% < mypic.pic dd -bs 128 -count 1
   x8r8g8b8        -226        -256          87          50  [...]
# -226+10 -256+15 86-20 50-6
% crop -r -216 -241 67 44 mypic.pic > mypic_crop.pic

More information on crop -r at Crop Mathematics (3.5.1).

pic

Add 10 pixels of white border, then add 4 pixels of plan9 blue:

% crop -i -10 -b 255 255 255 mypic.pic | crop -i -4 -b 159 237 239 > mypic_with_border.pic

pic

3.3 resize(1)

Make your pictures bigger or smaller.

pic

% file mypic.pic
mypic.pic Compressed plan 9 image or subfont, depth 32, size 365x559

To preserve the original aspect ratio, only define x or y.

% resize -n -y 245 mypic.pic > mypic_resized.pic
% file mypic_resized.pic 
mypic_resized.pic: Compressed plan 9 image or subfont, depth 32, size 160x245

pic

You can of course combine everything:

% crop -i 20 mypicture.pic | resize -n -x 640 -y 200 | page

pic

3.4 rotate(1)

Turn pictures around. Flip them upside down. You can only rotate in increments of 90.

pic

Rotate by 90 degrees clockwise:

% rotate -r 90 my.pic > rotated.my.pic

Flip upside down and mirror horizontally:

% rotate -ul > flipped.my.pic

3.5 Specific Canvas Size

For when you need to define an exact size of your drawing area.

• start paint(1)
• touch the screen with a white brush a little (you have to do this so that the next step saves the picture as an image file and not an empty file)
• w empty_canvas.pic
• if you run page empty_canvas.pic, you should see a white rectangle
• resize -n -x 250 -y 250 empty_canvas.pic > empty_canvas_250x250.pic (this will fail if the file is empty)
• cp empty_canvas_250x250.pic mypicture.pic
• paint mypicture.pic

The final command will open paint(1) with a canvas size 250 pixels tall and wide. However you cannot actually see the edge of it. Select the fill tool, pick a random color and middle click it. You will see a clear division between the canvas and the rest of the window. Save the picture and run file mypicture.pic. You'll see that it reports 250x250.

pic

Once you start drawing, you will again realize that paint(1) does not prevent you from drawing over the edge of your canvas. Instead of ignoring those lines, it will expand the picture (2.2).

pic

There are a three options:

• not caring about the lines that go over the edge of your canvas, and using mathematics to crop them off after you're done drawing
• priming your canvas with an even extra margin that you can crop off after you're done drawing
• just draw crop marks

3.5.1 Crop Mathematics

pic

Once you have this finished picture that was intended to be 250x250 pixels large, we can see with file(1) that it grew to 316x294.

term% file 250x250.pic 
250x250.pic: Compressed plan 9 image or subfont, depth 32, size 316x294

Firstly let's use vcrop to minimize the extra margin. Save the cropped picture and open it with page. Zoom in real close until you can confidently see how many pixels are going over the edge of your desired canvas.

pic

Examine how many pixels it goes over the edge. In my instance it is: 1px to the left, 2px to the top, 2px to the right, 3px to the bottom

Compare to the actual size of the picture:

term% file 250x250.pic 
250x250.pic: Compressed plan 9 image or subfont, depth 32, size 253x255

Do the mathematics:

Get absolute coordinates of your picture.

% < 250x250.pic dd -bs 128 -count 1 # get the coordinates
   x8r8g8b8         612         283         865         538         381  [...]

The first four numbers 612 283 865 538 are the coordinates.

#The formula
 crop -r a b c d 
a=612 + amount of pixels to remove from the left   (612+1=613)
b=283 + amount of pixels to remove from the top    (283+2=285)
c=865 - amount of pixels to remove from the right  (865-2)
d=538 - amount of pixels to remove from the bottom (538-3)

% crop -r 613 285 863 536 250x250.pic > finished_picture.pic

pic

Done.

3.5.2 Extra Margin

Instead of having to do rectangular crop mathematics, it's more convenient to prime your canvas for drawing over the edgeline before you start.

  % resize -n -x 250 -y 250 empty_canvas.pic > empty_250x250.pic
  % crop -i -25 -b 250 100 100 empty_250x250.pic > empty_with_margin_250x250.pic
  % cp empty_with_margin_250x250.pic mypicture.pic

pic

This will give you a 250x250 white canvas with a 25 pixel room for error on each side. Draw your picture. You can't go over the red space or the canvas will expand unevenly and you'll have to do crop mathematics.

pic

  % crop -i 25 -b 250 100 100 mypicture.pic > finished_picture.pic

pic

And just like that the extra red space is removed and the finished output is exactly the desired 250x250.

3.4.3 Just Draw Crop Marks

This is mainly the same as the first option, but with the eraser tool in mind.

Open your empty canvas in paint. Middle click a random color to see the division. Zoom in real close, select the smallest brush and draw crop marks into the top-left and bottom-right corners.

pic

You can change the background color to whatever you want now.

After you're done drawing, minimize the extra space with vcrop and use crop mathematics.

3.6 Faux layers: Slight Return

Acquire pico:

% git/clone https://github.com/qwx9/pico

It's a script you run. It is an incredibly powerful tool for manipulating images. The following is just a nail clipping of all it can do. Learn more about it: nopenopenope.net/posts/pico

In this example, I am using the color HotPink (#ff5fd7) as the sketching layer. I drew over it with black. The finished picture is called pink_layer.pic.

pic

Get the decimal values of 0xff 0x5f 0xd7 with pc(1):

term% pc
; dec(0xff)
255
; dec(0x5f)
95
; dec(0xd7)
215

Replace HotPink layer with background color (white):

#the formula
RR, GG, BB = decimal values of the color to replace
OR, OG, OB = decimal values of the target colorj
(for white you can use either 255,255,255 or Z,Z,Z)
(im[x,y,0] == RR && im[x,y,1] == GG && im[x,y,2] == BB) ? (z == 0 ? OR : z == 1 ? OG : z == 2 ? OB : Z) : im

#example
term% pico
!r /usr/glenda/pink_layer.pic im
(im[x,y,0] == 255 && im[x,y,1] == 95 && im[x,y,2] == 215) ? (z == 0 ? Z : z == 1 ? Z : z == 2 ? Z : Z) : im

page(1) opens with the edited picture. Middle mouse, write, enter the file name you want to save it to.

pic

Replace every color that is not white with black:

#the formula
RR, GG, BB = decimal values of the color not to replace
OR, OG, OB = decimal values of the color to replace everything else with
(im[x,y,0] != RR || im[x,y,1] != GG || im[x,y,2] != BB) ? (z == 0 ? OR : z == 1 ? OG : z == 2 ? OB : Z) : im

#example
term% pico
!r /usr/glenda/pink_layer.pic im
(im[x,y,0] != Z || im[x,y,1] != Z || im[x,y,2] != Z) ? (z == 0 ? 0 : z == 1 ? 0 : z == 2 ? 0 : Z) : im

pic

Replace every color that is not black with blue:

(im[x,y,0] != 0 || im[x,y,1] != 0 || im[x,y,2] != 0) ? (z == 0 ? 120 : z == 1 ? 0 : z == 2 ? 215 : Z) : im

pic

3.7 Tracers Work Both Ways

Would you like to trace any picture on the internet? You can. This example again makes use of pico.

Procure an image file, convert it to 9front format.

% hget http://img.triapul.cz/fahwui.jpg | jpg -c9 > to.trace.pic
% pico
!r to.trace.pic im
z == 3 ? Z : (im + Z) / 2

page(1) opens - write to to.trace.bright.pic.

Open to.trace.bright.pic in paint(1). Right click one of the default colors and put in HotPink: ff5fd7.

% paint to.trace.bright.pic 

Draw over the picture. Save it.

pic

% pico
!r to.trace.bright.pic im
(im[x,y,0] != 255 || im[x,y,1] != 95 || im[x,y,2] != 215) ? (z == 0 ? Z : z == 1 ? Z : z == 2 ? Z : Z) : im

page(1) opens - write to whatever.pic

pic

3.8 Palettes

Examine git.sr.ht/~amavect/makeu

4 Get it out!

Now you want to show your drawing to your friends.

4.1 Conversion

Since anything you can draw in 9front is basically pixel art, there's no reason to convert your picture to anything but PNG. But nobody will stop you. See jpg(1) to explore all the other formats. PNGs will be always smaller and sharper (read: look exactly like they did in paint(1)) than JPGs.

% topng my_picture.pic > my_picture.png

That's it.

You cannot use paint(1), crop(1), vcrop(1) on PNGs (or any other format that's not in image(6)). You can still display them with page(1).

If you ever lose your original, you can convert the PNG (or any other PNG) back to 9front's format.

% png -c9 my_picture.png > my_picture.pic

Afterwards you can edit my_picture.pic again.

4.2 Stop 9front

A picture is produced, cropped, converted, but how can you post it to your social medium now? Following is a list of methods, sorted from simplest that require no further technical skills and understanding, to less simple:

• open your picture in page(1), take a picture of your plan9 computer screen with a mobile phone
• connect a FAT usb drive to your plan9 computer and copy the picture to /shr/sdS0M3TH1NG
• sshfs(4) the picture to a unix computer
• drawterm into your plan9 computer from a unix computer, copy the picture to /mnt/term/some/where (this is your unix computer's drive)
• post it on snac with mothra(1)
• email it to yourself from your plan9 computer
• sshfs(4) the picture to a a virtual machine inside your plan9 computer
• copy the picture to your plan9 webserver and download it from a different device

pic

5 EOF

Now you really know How to draw (with 9front).

5.1 Special Thanks

sl, qwx, rodri, qrstuv, aiju, cinap, noodle, Renée French, Tom Duff

pic

5.2 Resources

• 9front
• Image Manipulation on Plan 9 Using pico
• fuck art
• Free Carrots #8: How to draw
• occ
• process
• snac
• I'm not really Stanley Lieber

I don't even use plan9.

This month, the U.S. Department of Education began rolling out a new accountability test that most colleges and universities will soon have to pass.

The test itself is simple: If an undergraduate program's graduates don't earn more than workers who never went to college, that program could be cut off from federal student loans. The same goes for any graduate program whose graduates earn less than someone with only a bachelor's degree.

"If a program cannot show that it leaves its graduates financially better off than if they had never enrolled, it should not be underwritten by federal taxpayers," said Under Secretary of Education Nicholas Kent in a recent statement.

But this new test, known as "do no harm," raises some thorny questions about the purpose of college. Like: Is it just about making more money?

Some advocates for postsecondary arts education think not.

"Earnings is only a small piece of that puzzle," said Lee Ann Scotto Adams, executive director of the Strategic National Arts Alumni Project (SNAAP), a nonprofit that studies the careers of arts graduates.

She and Doug Dempster, the president of SNAAP, worry the new test might lead colleges and universities to preemptively slash low-earning creative arts programs in music, theater, studio art and design. Dempster says that could lead to a further devaluing of jobs that are critical to a well-functioning society.

"We know we need nurses. We know we need journalists. We know we need early childhood educators," he said. "We don't know how many artists we need, but I can guarantee that if you eliminate access, we will impoverish our cultural life nationally."

How the new standard will work

The new earnings test comes courtesy of last year's One Big Beautiful Bill Act, which included a slew of big higher education policy changes meant to address rising concerns over the cost and value of college.

Higher education experts across the political spectrum told NPR the test sets a pretty reasonable expectation: In many states, federal data shows, graduates of bachelor programs will have to earn a minimum of about $30,000 to $41,000 a year for their program to pass.

"This is really a very low floor," said Christopher Madaio, a senior adviser at the nonprofit The Institute for College Access & Success. "I mean, high school earnings is not an exceedingly high metric for a program to meet."

Programs fail the test when they don't meet the earnings requirement for two out of three consecutive years.

The current test does not take student loan debt into account, which means there's no way to distinguish between a graduate who is struggling with low pay while being debt-free and a graduate who is struggling with low pay while also paying off tens of thousands of dollars in loans.

The Education Department says it will begin calculating the first year of graduate earnings in early 2027, and "some programs could be designated as low-earning outcome programs beginning in the 2028-2029 [financial aid] award year."

The kinds of programs that are likely to fail

According to Education Department estimates, the vast majority of undergraduate and graduate programs should easily pass the new earnings test.

But more than 800,000 students attend a program that would likely fail the measure, according to department data. Roughly half of those students are enrolled in for-profit schools, which already have a reputation for shortchanging students.

Other takeaways from the department's data:

• About 18% of undergraduate certificate programs, which often bill themselves as career-focused fast tracks, would fail the earnings test. Specifically, certificate programs in cosmetology and somatic body work have the highest predicted failure rates.
• Two-year associate degree programs have the next highest failure rate, at 6%. Associate programs that train specialized educators, including early childhood educators, are the most likely to fail.
• Most traditional, four-year bachelor programs fare well, with roughly 1% failing the earnings test. When these programs do fail, it's often in areas like theater, music and studio art.
• About 4% of master's degree programs would fail, with the highest failure rates for programs teaching mental and social health services.

For one music teacher, it was "never about the money"

Some of the United States' most prestigious music programs — known for training the country's most talented young musicians — are among the 14% of bachelor music programs predicted to fail the new earnings test, according to Education Department data. That includes The Juilliard School in New York City, the New England Conservatory in Boston and Indiana University Bloomington's Jacobs School of Music.

The undergraduate music program that Cindy Flores attended at Portland State University (PSU) also wouldn't pass. Flores teaches mariachi music to middle and high school students at Salem-Keizer Public Schools in Oregon's Willamette Valley.

Cindy Flores smiles as she teaches mariachi to students at McKay High School in Salem, Oregon. "If it wasn't for PSU and the loans I could get … I wouldn't be a Mexican American mariachi teacher for my Mexican American students," she said. Eli Imadali/OPB

Her path to becoming a full-time music teacher started with studying music education at PSU; then she got an educators license from Western Oregon University — and she used federal student loans to help pay for all of it.

She now holds close to $55,000 in federal student loan debt.

Flores said she wouldn't be where she is now without that access to federal aid.

"If it wasn't for PSU and the loans I could get … I wouldn't be a Mexican American mariachi teacher for my Mexican American students," she said.

But given the new federal test, future PSU music students might not have the same access to federal student loans that Flores did.

She said she feels lucky to have found a job that she's passionate about and that pays a living wage. But, for her, a career in music was about much more than a paycheck.

"It is never about the money," she said. "I realized I wanted to have a career in music when I was in the eighth grade, because every music teacher I had were such good role models in my life and I wanted to be part of that community."

Defining success in the arts

SNAAP's Lee Ann Scotto Adams said the federal government's one-size-fits-all accountability approach doesn't make sense for students graduating from creative arts programs because wages aren't the only measure of success for studio artists, musicians and designers.

"Yes, you need to earn money to make a living, but we see our creative workers want the ability to have independence in their work. They want jobs that are socially conscious. They want to make an impact culturally," Scotto Adams said. "These are all metrics that fall outside of just straightforward earnings metrics."

She also takes issue with looking at earnings in the first few years after graduation. Scotto Adams points to SNAAP survey data that shows arts graduates often have unpredictable incomes at the beginning of their careers, but their pay tends to stabilize and increase over time.

"Looking at earnings as the sole metric of success is very limited, and that's because artists have nonlinear careers," Scotto Adams said. "For the most part, people who graduate from these programs move into careers that they're personally satisfied with."

Students considering any of the at-risk programs won't immediately lose access to federal aid. While the accountability test is being rolled out this month, its implementation will be phased in over the next couple of years.

THE NEW GIANT UNDERWATER “JELLYFISH” ROUNDABOUT HAS BECOME THE LATEST FAROE ISLANDS TOURIST ATTRACTION

This is no ordinary roundabout. It is part of a marvel of engineering containing the world’s first undersea roundabout, with an illuminated, sea blue central pillar decorated by Faroese artist Tróndur Patursson.

Already a hit on social-media, the colorful tunnel network linking the two largest islands in the Faroe Islands has become a big draw for foreign visitors.

The 11.2 km (6.9 miles) long subsea tunnel network links the cosmopolitan capital of Torshavn with the second most populous island and has cut down traveling time between these two places from more than one hour driving time along the islands mountainous roads to only 15 minutes via the new subsea tunnel.

The subsea tunnel network named Eysturoyartunnil opened on 19 December 2020, after only 4 years of construction, and is expected to transform the Faroese society, connect people, regions, and economies in new ways.

In the heart of this, 72 meters below the surface, is the worlds first under water roundabout.

In the centre of this roundabout is a giant central pillar of natural rock, left behind during the blasting constructions. This giant pillar is now illuminated and decorated by a prominent Faroese artist, Tróndur Patursson. Around the pillar is an 80-metre steel sculpture represents figures in full size holding hands around the roundabout. They stare inwards at the light like worshippers around a volcanic fire. “The figures are walking from darkness into the light,” says Patursson, “And they symbolise the very Faroese idea that by joining hands and working together we achieve great things”, the Faroese artist said to the Guardian

• 

  This giant pillar in the center of the roundabout is illuminated and decorated with an 80-metre steel sculpture represents figures in full size holding hands around the roundabout.ese artist, Tróndur Patursson. Photo by Ólavur Frederiksen

• 

  77 year old Tróndur Patursson, the Faroese artist behind the tunnel decorations, here photographed with Teitur Samuelsen, CEO of Eysturoyar tunnel holding the photo lamps. Photo by Bardur Eklund

• 

  Is it a underwater roundabout, jellyfish or a alien UFO spaceship? Photo by Bardur Eklund

• 

  When motorists enter the tunnel, they experience a stylish entrance with harmonious arches and are later met by the roundabout, which is bathed in light so that it appears as a modern art installation. Photo by Olavur Frederiksen

• 

  The 11.2 Km long subsea tunnel is the second longest in the world. Photo by Ólavur Frederiksen

• 

  The entrance to the tunnel at the Runavík side. Photo by Ólavur Frederiksen

The new subsea tunnel also connects the two sides of the Skálafjørð bay area and cuts down the driving distance from 25 km to 5 km. Photo by Ólavur Frederiksen

The singled tube two-laned undersea tunnel, which takes around 8 minutes to drive through, is 189 meters (620 ft) below the water´s surface at the lowest point, and has three tubes which meet at the colourful roundabout.

One of the tubes connects with Tórshavn, the capital, on the island of Streymoy- to the left on the picture above. The other two tubes connect with the two bay areas of Skálafjørður fjord on the island of Eysturoy, on the right on the picture, helping to cut down travel distance between these two bay areas from 25 km down to just 5 km.

Additionally the tunnel helps shortening the driving time between the Faroe Islands´ two largest cities, Tórshavn and Klaksvik, will half. From 70 minutes to around 35 minutes.

Under the road, an advanced rain and wastewater system of pumps and kilometres of pipes ensures that rain and surface water are kept away from technical installations and the carriageway, so that road users can safely and safely enjoy the tunnel’s harmonious expression.

While the road users’ gaze at the beautiful tunnel decorations, gravity ensures that the water is led away from the cars and the carriageway via gratings and pipes and down to the lowest point in the tunnel, where large 16 bar pumps send the water back to the surface and out into Skálafjørður fjord.

The driving experience through Eysturoyartunnil, the second longest car traffic subsea tunnel in the world, can be enriched even more by tuning in on FM radio 97.00 while driving through the colourful tunnel.

On that channel you can listen to the Faroese musician and sound-engineers special tunes composed for your ride under the seabed.

At FM radio 97.00 you can listen to special music tunes composed by Faroese Jens L. Thomsen, while driving through the Eysturoyar tunnel. Photo taken at the entrance of the tunnel by Bardur Eklund

The whole Eysturoyar tunnel project was constructed by the Faroese public limited company Eystur- og Sandoyartunlar and was the largest single investment ever made in the Faroe Islands, totalling at around 260m Euros.

Driving through Eysturoyartunnil costs a toll fee of 75 Danish krona (around 10 Euros) each way and is billed automatically as a camera scans your license plate. Without a yearly subscription the toll fee is though 175 Dkk (24 Euro) each way.

The income from this new tunnel is expected to fund the next tunnel projects on the Faroe Islands.

Construction workers celebrating the breakthrough in the Eysturoy Tunnel on 7 June, 2019. Photo by Photo by Ólavur Frederiksen.

Crazy about tunnels

Faroese build tunnels like no other. We love them. The 18 islands making out the Faroe Islands has 53,000 inhabitants and now 20 tunnels, of which three are long tunnels under the sea. Two more are already under construction, and another 14 are on the drawing board or wish list.

Map showing the current 20 tunnels in the Faroe Islands (including the 3 subsea tunnels) and the many planned tunnels.

The biggest of the future tunnel projects will be the tunnel from the southmost island of the Faroe Islands, Suðuroy, to the island of Sandoy. The tunnel is expected to cost around 3.4 billion DKK ( 450 million Euro) and will be around 22-24 kilometres (13-15 miles) long, making it the longest car traffic subsea tunnel in the world.