Same deal as always: I haven't tested everything here, and the last lines of each entry are what I'd be tempted to build, not promises.

01. Tocaia

github.com/manipuladordedados/tocaia

A small Gopher client written in C89 with POSIX in mind. It has a text interface for walking around Gopherspace, with menus, text files, searches and back and forward history, and it needs nothing more than a C compiler: clone it, run make install and you're in. The name is Portuguese for an ambush. A client this light would be an easy thing to offer every user on runv.club.

02. Telescope

github.com/telescope-browser/telescope

A browser for the small internet, inspired by Emacs and w3m, that speaks Gemini, Gopher and Finger. It has the expected things (tabs, bookmarks, history, client certificates) and a privilege-separated design, and the code follows OpenBSD's style guide. The README lists fun as the first goal and says the project is entirely handwritten, with contributions generated by LLMs not accepted. For certificates it goes beyond plain trust on first use, with three levels: untrusted, trusted and verified out of band. Out of the box, the external editor is ed.

03. Rogallo

github.com/davep/rogallo

A terminal client in Python for six protocols: Gemini, Titan, Spartan, Gopher, Nex and Finger. Bookmarks and history both have search, there's a command palette, a source viewer and mouse support, and it renders ANSI escape sequences inside pages. On the Gemini side it handles input prompts, with an option to type them in your own editor, and it can create client certificates for you and keep one per capsule. Install it with uv tool install rogallo or pipx install rogallo. Pointing it at Soledade over Nex would be my first test.

04. Alhena

github.com/mochaman/alhena

For people who'd rather not live in a terminal: a desktop browser for Gemini, Gopher, Spartan and Nex, built on Java 21, with dozens of themes, color emoji and any system font for text. The feature list is long. Inline images, audio and video through VLC, Titan uploads, split view, gemlog and Atom subscriptions, a Gemtext-aware editor, an HTML-to-Gemtext converter, and backups and remote sync for your settings and certificates. There are installers on the project page. It's the one I'd hand to a friend who wants to see what Gemini looks like.

05. smolserve

github.com/davep/smolserve

From the same author as Rogallo, a lightweight server for Gemini, Gopher, Finger, Spartan and Nex at once, meant for local testing and documentation. Run it with no setup and it listens on 127.0.0.1 with Gemini on 1965, Gopher on 7070, Finger on 7979, Spartan on 3000 and Nex on 1900, creating sample content folders and self-signed certificates if they don't exist. The clever part is exec mode: smolserve exec -- pytest keeps the servers up only while that command runs, then shuts them down and returns its exit code. Not to be confused with SmolServ, without the e, as the README points out. It would be a good place to preview a capsule before it goes live.

06. fleur

github.com/theobori/fleur

A framework in Go for building Gopher applications, plus a CLI that serves files. You map paths to functions with regular expressions, so a request for /dice can answer with a fresh gophermap holding a dice roll, and extensions can add new item types to the gophermap format itself. Gopher over TLS works on the same port as plain Gopher. The CLI can also serve personal Gopherspaces, turning /~username/ into that user's public_gopher folder, which is exactly how a pubnix likes it. The name is French for flower, and there's a NixOS module. runv.club's users could each get a gopher hole this way.

07. Gigi

github.com/Fuwn/gigi

"An honest Finger protocol server", with few features, "the way a Finger server should be." It answers requests from static files, or dynamically by running whatever executable you put at .gigi/do, which is off by default because, as the README says, running code on request is a real risk. There's a live instance you can poke at with finger fuwn.me, or with echo | nc fuwn.me 79 if you don't have a client. It runs with Go, Nix or Docker. After the WebFinger guide, the original finger is the obvious next toy.

08. miniflux-gemini

github.com/cljoly/miniflux-gemini

Exposes a Miniflux instance over Gemini, so you can read your feeds from a Gemini browser. Login uses client certificates: you add a row that ties your certificate's fingerprint to your Miniflux address and an API token, and the server knows who you are from then on. The README marks it as a work in progress with thin documentation, so expect to read some code. Feeds read from Telescope on an old laptop sounds like a nice quiet morning.

09. Neon Modem Overdrive

github.com/mrusme/neonmodem

A BBS-style command-line client that puts Discourse, Lemmy, Lobsters, Hacker News and Hyperuplink behind one text interface. You can list forums, posts and replies on all of them, read without an account, and post or reply once you log in. It's written in Go with Bubble Tea. On the name, the README says it plainly: "And yes, you heard that right, I really did call it Neon Modem Overdrive." Packages exist for Arch, through the AUR, and NetBSD.

10. tmpbbs

github.com/mmb/tmpbbs

An ephemeral, anonymous forum. Posts live in memory and disappear when the process stops, and the whole thing is one static binary that needs no internet and no disk, small enough for an old wireless router. Durability comes from linking instances: posts can replicate in one direction or both, so you can build a mesh, a tree, backups or read-only copies. Every instance serves its own binary at /self, so anyone who visits can start another one. There are tripcodes in the name#secret style and post IDs you can read aloud. A forum that only exists for the length of an event is a lovely idea.

11. term.everything

github.com/mmulet/term.everything

Runs GUI apps inside your terminal, even over SSH. It's a Wayland compositor written from scratch in Go, with a little C, that draws windows to the terminal instead of to a monitor. Quality depends on how many rows and columns you have, so shrinking the font makes the picture sharper, and in terminals that show images, like kitty or iTerm2, windows can render at full resolution. With a small hack it runs Doom. The roadmap has three steps, and the project sits on the first: "Term some things". The HowIDidIt.md file is a good read about Wayland on its own.

12. cool-retro-term

github.com/Swordfish90/cool-retro-term

A terminal emulator that looks like an old cathode-ray screen, with glow, curvature and scanlines, and profiles like amber, green and IBM DOS. It's built on the QML port of Konsole's terminal widget, needs Qt6 and runs on Linux and macOS. Most distributions already package it, and there are AppImage and dmg builds on the releases page. It's been around for years, and opening it before an ssh runv.club session would set the mood.

13. DOS ex Machina

github.com/pedrocatalao/dos-ex-machina

An early 90s beige-box PC on your screen, case and CRT included, that boots a real DOS. It powers on, runs its POST and hands over to DOSBox Pure at the prompt. Nothing is a photograph: the machine is drawn procedurally at your display's resolution, and the tube has phosphor persistence, curvature, scanlines, an aperture-grille mask and light from the picture spilling onto the plastic. The sound gets the same care, with the relay and degauss thump at power on, fans, the disk spinning up, the floppy when a program loads, and a mechanical keyboard cut from recordings of real typing. C: is a folder on your computer, SETUP lets you pick processor, memory and even a 3dfx card, and CATALOG downloads freeware and shareware from where the authors published it. There are no downloads yet, so you build it from source. I'd fill that C: drive the first evening.

14. Launch!

github.com/therenegar/launch

A command launcher for any DOS from 3.3 up, on a 286 or better with EGA or VGA. It works with MS-DOS, PC DOS, DR-DOS and FreeDOS, on real hardware or in DOSBox and 86Box. Instead of replacing the prompt with a graphical shell, it keeps you in text mode and pops a menu over whatever is on screen when you press Ctrl+Alt+\, then runs your choice by typing it for you through keyboard macros. Around that come accessories (calendar, calculator, journal), text-mode games like Snake and Solitaire, screensavers including a starry skyline and a fake disk defrag, and integration with Windows 3.x. It installs from a floppy image, or from a real floppy if you have one. It would look right at home inside DOS ex Machina.

15. Serial Experiments Lain, decompiled

github.com/Y0oshi/lain-psx-decompiled

A decompilation of Serial Experiments Lain for the PlayStation, the 1998 Pioneer LDC game. All 321 game functions are now C that compiles with the original PsyQ toolchain into an executable byte-identical to the retail one. On top of that sits a native client for Windows, macOS and Linux that runs the game with no emulator, and it plays the whole thing, both discs and all four endings. No game data is included: you dump your own discs and the launcher checks them. It also adds mods, Lua scripting and a tab of content found on the discs that the game never uses. Issue four had lainTSX, a remake of the game's interface in the browser; this one goes all the way down to the original code.

16. PSP Web Recomp

github.com/snuri00/psp-web-recomp

PSP games in a browser tab. The game's MIPS code is translated ahead of time into C++, compiled to WebAssembly and linked against a small reimplementation of the PSP's operating system and graphics chip, drawn with WebGL2. The first game brought up is God of War: Chains of Olympus, which the README says runs at 60 frames per second in the scenes measured so far, at up to four times the PSP's resolution, and on phones with touch controls; Ghost of Sparta followed. You bring a disc image of a game you own and the scripts turn it into a page on your own machine, about 2 GB of disk per game. The author is honest that both games share one engine, so a game from another studio will probably stop at a system call nobody has written yet. Reading the "How it works" section is worth it even without a PSP disc in the house.

17. FUZIX

github.com/EtchedPixels/FUZIX

"Because Small Is Beautiful." A Unix-like operating system for small and old processors, made by fusing several forks of UZI and growing them from Version 7 toward System III and System V, with some POSIX on top. The kernel boots to userspace on a long list of chips: Z80, 6502, 6809, 68000, 8080, 8085, ARM32, even the ESP8266. The README calls it "an art project in computing", says the best support is code or docs, and if you'd rather spend money, suggests buying a homeless person a pizza or a coat. Some prebuilt filesystems are on fuzix.org. It's a good excuse to get a Z80 board.

18. Unix History Repository

github.com/dspinellis/unix-history-repo

The whole history of Unix as one Git repository, from 1970, when it was a 2.5 thousand line kernel and 48 commands, to 2025, when it's a 41 million line system. It was built by stitching together 22 snapshots from Bell Labs, Berkeley, the 386BSD team and modern FreeBSD, and it holds about 850 thousand commits and some 2,700 identified contributors, the early ones found through primary research. The repository is regenerated from scratch, so contributions go to its sister project, unix-history-make. Clone it, check out the PDP-7 snapshot and read where all of this started.

19. Zork I

github.com/historicalsource/zork1

The source code of Infocom's Zork I, the 1980 game by Marc Blank, Dave Lebling, Bruce Daniels and Tim Anderson. It's written in ZIL, the Zork Implementation Language, built on MDL, a Lisp dialect from MIT. The files are a snapshot of Infocom's development directory at the time the company shut down, including some that were discarded along the way. There's no official compiler left, but the community-made ZILF has been shown to compile them with minor issues. In November 2025 the repository got an MIT license. The parser, in gparser.zil, is the file I'd open first.

20. Farbrausch tools 2001-2011

github.com/farbrausch/fr_public

Ten years of tools from Farbrausch, the German demoscene group, released as they were. The README is upfront: "This is not cleaned up. This is the raw deal, some from old hard drives, some fresh from various SVN repositories." Inside are Werkkzeug3, used for many of their demos and intros, the V2 synthesizer behind all their intros plus kkrieger and debris, the kkrunchy executable packer, and the data files for several productions. Everything is under a BSD license or in the public domain, and the main branch builds with Visual Studio 2010. If you've ever watched debris and wondered how, the answer is in there.

Bonus tabs

A few more I refuse to close:

ncgopher · A Gopher, Gemini and Finger client in Rust with an ncurses interface.

ange · A Gopher webring built on fleur (entry 06), with its members kept in SQLite.

IOCCC winners · Every winning entry of the International Obfuscated C Code Contest, which started in 1984.

overengineeRING · A webring of people who make things. You join with a pull request and a small YAML file.

blogtato · A command-line RSS and Atom reader inspired by Taskwarrior, with sync through git.

Gitmal · Turns a Git repository into static HTML pages with files, commits and syntax highlighting.

xxh · Takes your favorite shell with you over SSH, without installing anything on the host.

That's issue six. Half of it talks to servers most people have never heard of, and the other half boots machines nobody sells anymore.

Found a strange repository, a forgotten tool or a small piece of software I should see? Send it my way. Reader suggestions are welcome for issue seven. And if you make something with any of these, I'd like to see it.

Happy wandering!
Pablo

This is their story, from a terminal in 1976 to a Debian box in Brazil in 2026.

Why a tilde?

Start with a keyboard. In 1976, Lear Siegler released the ADM-3A, a simple and cheap video terminal. On its keyboard, the key in the top right corner said Home, and printed on that same key was the ~ symbol.

That's a common explanation for why, in Unix shells, ~ means your home directory. The same terminal left another mark that's still around: the H, J, K and L keys had arrows printed on them, and that's why vi, and later Vim, move the cursor with those four letters.

From there, the rest follows. On Unix, ~pablo means Pablo's home folder. When the web arrived, servers started publishing a folder inside each user's home at addresses like server.edu/~pablo. For years, that was how a regular person put a page online: an account on a shared machine and a tilde in the address. Paul Ford, who comes back later in this story, put it well: the ~ is "a shortcut that says: 'Here is a person.'"

1982: dial in and wait your turn

The first public access Unix systems appeared in 1982: M-Net, in Ann Arbor, Michigan, and Chinet, in Chicago. By the late 1980s there were more than 70 of them.

There was no internet for regular people yet. You dialed the machine directly with a modem, and the number of people who could be online at the same time was the number of phone lines the system had. If there was only one modem, you kept redialing until whoever was connected logged off.

Long-distance calls were expensive, so most users lived in the same area code as the machine. The people you met online could literally live down the street, and sometimes you ended up meeting them in person. People used these systems mostly for message boards, mail and chat, close cousins of the BBSes of the same era, but running Unix, with all its tools available to anyone curious enough to learn them.

M-Net is still alive. In February 2025, SDF announced it had taken over the stewardship of the system, which it called the longest running public access Unix system.

SDF, the survivor

SDF deserves its own chapter. It started in 1987 as a bulletin board on an Apple IIe, run by Ted Uhlemann for a group of Japanese anime fans. The name comes from the anime Super Dimension Fortress Macross. In 1990 it became a Unix system, and since then it has never stopped.

It went through almost everything a computer can go through. In 1997 it had around 15,000 users and moved to Linux. Between 2000 and 2001 it switched to NetBSD on DEC Alpha machines and moved from Texas to Seattle. In 2001 it became a nonprofit. In May 2016 it had 47,572 registered users, and in 2018 it was the largest NetBSD installation in the world.

Today SDF offers a free shell account, web pages, Gopher, Mastodon, a gallery and even vintage systems you can log into, like TOPS-20 and ITS. Its home page has a copyright line that runs until 2065, and a note at the bottom says it was "generated using ksh, sed and awk."

The quiet years

In the 1990s, two things happened. Linux appeared in 1991, and suddenly anyone with an old PC could run their own Unix server. And the commercial internet arrived, with millions of new people online.

That was good and bad for pubnixes. Access got easier, but abuse came with it: spam, attacks on other machines, illegal files. Many systems had to close down services that used to be open, like outgoing connections and, in some cases, email. Then the personal computer won, people moved their lives to Windows and Mac, and later to social networks. A handful of systems kept going, like SDF, Grex and Nyx, but for about two decades pubnixes were mostly a thing for people who already knew them.

2014: a couple of drinks and a thousand nerds

On a night in September 2014, the writer Paul Ford was reading a 2004 post by Stevie Nicks and noticed she used tildes all over the place. He joked about it on Twitter. A friend replied that tildes were only ever properly used in front of usernames on shared hosting. A few drinks in, Ford registered tilde.club, promised a shell account to anyone who wanted one, and set up the cheapest server Amazon had.

He woke up to 100 people asking for accounts. In a few days there were around 600 members, more than a thousand on the waiting list, volunteers offering to help run the machine, and, at one point, $24 in an envelope slipped under his apartment door. People made pages, a webring, lists of who was online, and a lot of ASCII art dragons.

He told the story in an essay with a great title, "I had a couple drinks and woke up with 1,000 nerds", and repeated one sentence throughout it: "Tilde.club is one cheap, unmodified Unix computer on the Internet."

Twelve years later, tilde.club is still online, now running Fedora 43, with a list of active users at the top of the home page.

The town and the tildeverse

tilde.club closed signups fast, and that's how tilde.town was born. Its creator, ~vilmibm, had an account on tilde.club, but by the time ~vilmibm told some friends about it, there was no room left. A few days later, on October 11, 2014, came ~vilmibm's birthday, and the present on the wish list was a social Unix server. A friend stayed up all night helping with the setup. The idea was to keep the spirit of tilde.club, but make a place friendlier to less technical people, and one that would never have a user limit.

The town grew up. Today it runs on a physical server, pink and covered in stickers and graffiti, in a data center on the outskirts of Ottawa. Its members have connected from strange places, like a Sega Dreamcast:

Or Windows 98, which, according to the town's founder, is "the finest OS":

Other tildes kept appearing, and in time they found each other. The tildeverse is a loose association of these communities. Membership mostly means hanging out on the shared IRC network, tilde.chat, and there's a wiki anyone with an account on a recognized tilde can edit. Each server stays independent.

The member list today includes tilde.club, tilde.town, tilde.team, ctrl-c.club, envs.net, cosmic.voyage, texto-plano.xyz and rw.rs, which showed up in Neat Finds #02 with its sign-up by pull request. Outside the tildeverse there are many more, and each one has its own personality.

What you actually do on one

Less than you'd think, and more than it seems. You connect with SSH, and you're on a real computer, with other people. Type who and see who's logged in. Use finger to read someone's plan. Write a page by hand in ~/public_html and see it online a second later. Join the IRC channel and talk to people who are on the same machine as you.

Every tilde grows its own little traditions. On tilde.town there's feels, a blogging platform that runs in the terminal, which showed up in Neat Finds #05. Other places have shared gardens, webrings, collaborative fiction, games and bots. A lot of people also keep a Gopher hole or a Gemini capsule alongside their web page.

And it's a very good way to learn. Nobody grades you, nobody's watching your metrics, and the worst that can happen is a broken index.html.

And then there's runv

runv.club is our pubnix, a small public Unix server run from Brazil, on Debian.

The first version was online for a year and a half and closed in October 2026. Instead of burying it, the members decided together to start over, and I wrote about why we brought runv.club back. The new server is built from a repository with Ansible, the same way every time, with limits for every account and backups that go out to another machine.

It keeps the classic pieces: a shell over SSH or mosh, a page at runv.club/~you, a Gemini capsule, a Gopher hole, finger, twtxt, a forum in the terminal and #runvclub on tilde.chat. Since the relaunch, it has picked up a few new tricks:

• a blog that publishes from ~/blog to the web, Gemini and Gopher at once, and joins the planet with everyone's posts;
• a status line, like status "making soup", and a /now page;
• a photo gallery that removes location and camera data from your pictures;
• your own address at you.runv.sh, for an app on the server or a tunnel from your laptop;
• an email address you@runv.club, forwarded to the inbox you already use;
• proofs that your Mastodon, GitHub or own site belong to you, checked by the server;
• an account on lemmy.club, a forum federated with the rest of the fediverse.

The planet already has its first posts. Every request to join is read by a person, and we let in five people a week, so the place grows slowly. You can ask at the join page or straight from a terminal:

ssh join@runv.club

runv isn't the only one I look after. There's also noctem.cafe, a quiet OpenBSD machine, and Noctem 9, which runs Plan 9. I wrote about all three in Three small computers looking for neighbors. And if you'd like to build your own, there's a two-part guide, Build your own tilde.

Pick a machine

Forty-four years after M-Net and Chinet, the idea is still the same: one computer, a lot of people, and a folder with your name on it. If you've never had a shell account, pick a pubnix whose rules and mood you like, read the code of conduct, make an SSH key and ask for a spot. Then type who and say hello to whoever else is there.

This post is an attempt to untangle it. The first part has no real spoilers. After that, everything is on the table: the box, the week, the twist, the theories and the bits of science and computing hiding in the dialogue. If you haven't seen the film, watch it first and come back. Turn on the subtitles, because some of the most important lines are mumbled.

A film made by an engineer, for almost nothing

Primer was written, directed, produced, edited and scored by Shane Carruth, who also plays Aaron, one of the two leads. Before making films, Carruth had a degree in mathematics and worked as an engineer developing flight simulation software. He studied physics while writing the script.

The numbers are part of the legend:

• a budget of $7,000;
• a crew of five people;
• five weeks of shooting on the outskirts of Dallas, Texas, on Super 16mm film;
• a shooting ratio of 2:1, which means almost every take ended up in the film;
• two years of post-production, during which Carruth says he nearly gave up several times.

Most of the cast were his friends and family. He cast himself as Aaron because he had trouble finding actors who would stop "filling each line with so much drama." The time machine is a plain grey box, and its hum is a mix of a mechanical grinder and a car engine, with no digital effects.

In 2004 it won the Grand Jury Prize for drama at Sundance. It also won the Alfred P. Sloan Prize, which Sundance gives to films that deal with science and technology.

The setup

Aaron and Abe are engineers who, with two friends, build electronic gadgets in Aaron's garage on their own time, hoping one of them will sell. While working on a device meant to reduce the weight of objects, they notice something strange about what they've built.

The dialogue in these scenes is dense on purpose. The characters talk the way engineers talk to colleagues who already know the project: half sentences, jargon, no explanations. Carruth has said he wanted the audience to feel as lost as the characters are. The real subject, in his words, is the relationship between the two men breaking down because neither of them can handle what the machine gives them.

From here on, spoilers.

How the box works

The box was supposed to make things lighter. What it actually does is create a loop in time. When you switch it on, the inside of the box starts running forward like everything else. When you switch it off, the inside runs backward to the moment it was switched on, then forward again, back and forth, as long as anything is in there.

Abe figures this out the hard way. After repeated tests with a small toy, a fungus grows on it, and a lab tells him the fungus is ordinary but the amount of growth means years have passed, not days. He tries again with his wristwatch and confirms it.

The trick to traveling with it is simple and uncomfortable:

1. In the morning, you set a box to switch on at, say, 8:45, then go hide somewhere so you don't run into anyone.
2. In the afternoon, you come back and switch the box off.
3. You climb inside and wait as many hours as went by, six in the film, while the box runs backward.
4. You climb out at 8:45 in the morning. There are now two of you, and the other one is the version that is going to hide all day and climb into the box later.

If everything goes right, the other version climbs into the box in the afternoon and vanishes into the past, and you are the only one left. The rule they repeat is that each box can only be used once: you can't climb out of a box and then use the same box again, because your earlier self is already the one doing that.

The week

The film covers about a week in March, starting on a Monday.

Abe tells Aaron he has already done the trip once. They build a second box and start repeating the same day over and over, hiding in a hotel room and using what they know to make same-day stock trades. They try hard to change as little as possible, because the worst outcome would be failing to send their doubles back and getting stuck with two of each of them.

Cracks show up fast. Aaron gets reckless and starts imagining what else they could do. He has an ear bleed. Their handwriting gets worse. On Thursday, Aaron's phone rings in his hand while his other self, in the hotel, has the same phone, and they realize that history isn't fixed: it can be changed.

On Friday night, things get stranger. They notice Thomas Granger, the father of Abe's girlfriend Rachel and the man funding the project, following them. He has a beard he didn't have the day before. When Abe calls Granger, the real one answers from home. This Granger came from the future, using one of the boxes, for reasons nobody ever explains. When Aaron gets close to him, Granger collapses into a coma.

That's when Abe loses his nerve and reveals his secret: a failsafe. Early on Monday, before he ever showed the machine to Aaron, he had switched on a third box and left it running in a storage unit. It has been on for almost four days. He climbs in with oxygen and water, rides it all the way back to Monday morning, drugs his past self so that self never discovers anything, and goes to meet Aaron to stop the whole thing before it starts.

The twist: Aaron was always ahead

This is the part where almost everybody gets lost on a first watch.

When Abe arrives at the bench on Monday, Aaron is already there, with an earpiece in his ear, saying the same lines as the first time. When Abe passes out, it turns out Aaron isn't listening to a basketball game. He's listening to a recording of their own conversation. This Aaron has done all of this before.

Aaron found Abe's failsafe much earlier and kept quiet about it. He built boxes of his own, went back in time, drugged his original self and locked him in the attic (the noise his wife Kara mentioned), and lived the week wearing an earpiece with recordings, so he could repeat every conversation. He also discovered that boxes can be "recycled": you can't reuse the box you came out of, but you can carry a folded box with you, switch it on at the other end and use it later to go back again.

The usual reading of what we see is that there are three Aarons by the end. The original, drugged in the attic. A second one, often called Hooded Aaron, who leaves town. And the one we've been following since the bench scene, who is already the third.

Why go to all this trouble? The answer seems to be Rachel. At a birthday party on Monday night, her ex-boyfriend shows up with a shotgun. The film implies that in an earlier timeline this went badly, and that Aaron has been reliving those days to fix it. Back on Monday, the two of them work together to make the party end well, with Aaron stopping the gunman and becoming a local hero.

The ending

Abe and Aaron go their separate ways. Abe stays behind to watch over his original self and sabotage any attempt to build the machine again. Aaron, who can never go home because his family now belongs to the original Aaron, leaves the country. In the last scene, an Aaron is somewhere far away, directing French-speaking workers as they build a box the size of a warehouse.

The voice-over that runs through the film turns out to be a phone call: one of the Aarons telling the whole story to his original self. Near the end, he says: "You will not be contacted by me again."

The theories

Primer doesn't answer every question, and fans have spent two decades filling the gaps. These are the most common readings:

• The narrator is Hooded Aaron. The voice-over is the phone call from the Aaron who left town, explaining everything to the original Aaron he drugged. It's the most accepted reading.
• The title is the call. A primer is a first coat of paint, or an introductory book. One popular theory says the "primer" is the phone call itself: the instructions one Aaron leaves for another to start the whole cycle again.
• Granger's trip is never explained. Something in the future was bad enough to make him go back and follow the two of them. Whether that disaster was avoided, the film doesn't say.
• History can change. Unlike films where the past is fixed and every trip was "always" part of history, Primer shows timelines being overwritten. The ringing phone is the proof.
• Time travel hurts. The ear bleeds, the bad handwriting and the near-fatal reaction between Aaron and Granger all suggest the body pays a price, especially for anyone who has spent many hours inside the boxes.
• The warehouse. The final box is huge, which suggests that someone, somewhere, is planning something much bigger than stock trades.

Carruth once pointed to where some of the ideas came from: "Richard Feynman has some interesting ideas about time."

The science in the garage

The dialogue is full of real science, even if the machine is fiction.

The box needs superconductivity. A superconductor is a material that carries electricity with zero resistance, and it does something odd with magnetic fields: it pushes them out, which is why a magnet can float above a cooled superconductor. That's called the Meissner effect. The catch is temperature. Every known superconductor needs extreme cold, and a superconductor that works at room temperature, which is what the characters joke about building, remains one of the great unsolved problems in physics. In 2023, a material called LK-99 caused a frenzy online after a claim that it was exactly that, until labs around the world tried to replicate it and found it wasn't.

For their homemade version, they pull palladium out of a car's catalytic converter. Palladium is a real catalyst metal, and it's in catalytic converters for exactly that reason.

The box is sealed and filled with argon, a noble gas that barely reacts with anything. It's used in welding and in light bulbs for the same reason: to keep everything inside stable.

And the fungus is a beautiful detail: Abe uses biology as a clock. The amount of growth tells him how much time really passed inside the box, the same reasoning scientists use when they date things by measuring something that changes at a known rate.

The Feynman quote points to an idea from particle physics. In Feynman's diagrams, an antiparticle moving forward in time can be described as a particle moving backward in time. The box's back-and-forth loop between two moments has the same flavor.

What programmers will recognize

Anyone who works with computers will find a lot of familiar ideas in the box.

• Snapshot and restore. Switching on a box is taking a snapshot of a moment. Climbing in is restoring it. The box doesn't let you jump anywhere you want, only back to a point you saved earlier.
• The failsafe is a backup. Abe's secret box, running since before the experiment, is the backup you take before a risky deploy, so you can roll back if everything goes wrong. Aaron simply had an older backup.
• The earpiece is a replay log. Aaron records every conversation and plays it back so he can repeat his lines. It's like replaying recorded traffic against a system to reproduce the exact same behavior.
• "Recyclable" boxes are nested snapshots. You can't restore from the same snapshot twice, but you can carry a new one with you, take it at the other end, and roll back again from there.
• Two Aarons is split brain. In a cluster, split brain is when two nodes both think they're the primary and start making decisions independently. That's exactly what happens to Aaron, and to Abe, and their lives never merge back.
• The phone call is a race condition. Two copies of the same phone, one event, and only one of them can ring. The moment the "wrong" one rings, the state diverged.
• The muffin. On the second pass through Thursday, Abe eats a muffin while Aaron watches a game they already know the result of. It's the most relatable moment of time travel in the film: once you've replayed the day, you start optimizing small things.

How to watch it

A few things make Primer much easier:

1. Watch with subtitles. Key lines are spoken quietly or in the background.
2. Pay attention to Aaron's earpiece. Every time he's wearing it, ask yourself which Aaron he is.
3. Watch the handwriting and the ear bleeds. They show who has spent the most time inside the boxes.
4. Don't expect to get it all the first time. Nobody does. The film was built to be watched at least twice.

If it makes you feel better, even xkcd gave up. In its famous chart of movie narratives, the lines for Abe, Aaron and Granger go into a giant knot of scribbles and come out the other side as question marks.

Movie Narrative Charts, xkcd, CC BY-NC 2.5.

Docs do Murad, the recipe shelves

Docs do Murad is where I record, in Brazilian Portuguese, how I set up and keep running the things I use every day: the VPS, Docker, the servers at home, privacy, websites written by hand. The home page calls it a compendium, a catalog of recipes, and makes a point of saying what it isn't: not a feed and not a garden of drafts.

It's organized like a set of shelves:

• Essenciais: the ritual for a new VPS. Fresh Debian, Docker, Nginx and SSH closed to the street.
• Serviços: the biggest shelf, with more than a hundred recipes sorted by what they do (media, files, notes, network, metrics), each marked with the machine it runs on.
• Casa: the hardware at home, the machines called kaiser and nyx, and a lab with OPNsense, DNS and hostnames.
• Privacidade: browsers, passwords, disk encryption, and how to get around CGNAT without depending on the internet provider.
• Web à mão: making a site with plain HTML and CSS, Neocities and the small web, starting from a name and a folder.
• Trecos: the drawer, for everything that doesn't fit anywhere else.
• Papéis: opinion and longer pieces, from BSD to GrapheneOS to the craft itself.

There's also a glossary for words like POSIX, TTY and cgroup, a page of references, an index by tag and a changelog. The changelog describes itself well: not a blog, a log of the shelves. When a page moves to a new shelf, the old address redirects, so links don't break.

The recipes try to be honest about their limits. The first one, about preparing a new server, explains why Debian ("being able to repeat the setup and understand the services that are running weighs more than installing the novelty of the week"), and the certificate script that comes with it lists exactly what it doesn't handle, so nobody runs it blind. Some texts are mine and some are adapted from other writers, with credit on each page.

A few more details. It's built with Zensical and comes to close to 300 Markdown pages. Every page carries tags asking AI crawlers not to train on it. And the site has a mascot, Netuno, a cat who, according to the home page, thinks he has sudo.

Pablo, how?, the notebook

Pablo, how? is the English side, and a different animal. It's a digital garden: short notes that start small, grow, pick up links to other notes and sometimes get renamed. Nothing there is finished, on purpose.

The name comes from the question. It's where I write down how I do things: the server at home, the bug that took too long to find, the concept that finally clicked, the tool I use and why. The home page also tells the long version of how I got here, from the electronics I opened as a kid in Soledade de Minas to the Pentium MMX that showed up in 1997, and from Delphi to Linux, IRC and Python.

The notes come in four kinds:

• How I did it: real fixes, with the mess included. Taming an unstable i9-14900K, finding out why my GoToSocial RSS feed was empty, streaming from behind CGNAT, running a 24/7 TV channel from home.
• Concepts: things explained in plain words. Nostr, IPFS, microformats, LoRa, textcasting, Creative Commons, plus a short history of the Brazilian internet and a look at the operating systems of North Korea.
• Lists: pubnixes worth an account, Gemini capsules worth a visit, games you play in a terminal, small email providers worth paying for, and, because it's my garden, horror films few people have seen.
• Web by hand: a seven-part series that takes a site from an empty folder to a styled page with its own RSS feed, using only HTML and CSS.

It runs on Obsidian Publish, so every page has a small interactive graph of the notes around it, which is a fun way to wander. The Web by hand series even admits it on its first page: "I'm aware of the irony of writing a series about doing it all by hand." There are more than seventy notes so far.

Which one to open

If you want to do something, step by step, and you read Portuguese, go to the Docs. If you want to understand something, or see how a problem got solved, go to Pablo, how?. And if you want the story around all of it, you're already here.

The garden already links to the Docs, and this blog now links to both. Pick a shelf or a note that looks interesting and follow the links from there.

This post turns a plain Emacs into a comfortable place to write code. It assumes you've read the first Emacs guide, or at least that C-x C-f and M-x don't scare you anymore. Part II helps if you want to understand every line of the config, but you can follow along without it.

Everything here works on Emacs 29 and newer, unless I point out a version.

Projects

Most of programming happens inside a project, usually a Git repository. Emacs has project.el built in, and it figures out the project on its own: open any file inside a Git repository and Emacs knows where the project starts.

Everything lives under C-x p:

C-x p p: switch to another project
C-x p f: find a file in this project
C-x p g: search the whole project for a regexp
C-x p r: search and replace across the project
C-x p b: switch to a buffer from this project
C-x p D: open Dired at the root of the project
C-x p d: pick a folder inside the project and open it in Dired
C-x p s: open a shell at the root of the project
C-x p e: open Eshell at the root of the project
C-x p c: compile the project
C-x p !: run a shell command at the root
C-x p k: close every buffer of this project

C-x p p remembers every project you've opened. Pick one and Emacs asks what you want to do there: find a file, search, open a shell, and so on. Switching between three projects becomes a matter of a few keys.

If a folder isn't a Git repository but you still want Emacs to treat it as a project, you can teach it other markers, like a package.json or a requirements.txt, through the project-vc-extra-root-markers option.

Language servers with Eglot

A language server is a program that understands one language deeply: where every function is defined, what a variable's type is, what's wrong with the line you just wrote. VS Code, Neovim and Emacs all talk to the same servers, using the same protocol. Emacs's client is called Eglot, and it's built in since version 29.

First, install the server for your language. Some common ones:

npm install -g pyright # Python
go install golang.org/x/tools/gopls@latest # Go
rustup component add rust-analyzer # Rust
npm install -g typescript-language-server typescript # JavaScript and TypeScript
sudo apt install clangd # C and C++, or your system's package manager

Then open a file and run M-x eglot. Eglot already knows which server goes with which language, so most of the time there's nothing to configure. For Python alone it knows about a long list of servers, from pyright and basedpyright to pylsp and ruff, and it picks the first one it finds installed.

From then on, these keys do the heavy lifting:

M-.: go to the definition of what's under the cursor
M-,: come back
M-?: find every place that uses it
M-x eglot-rename: rename it everywhere
M-x eglot-code-actions: quick fixes the server suggests
M-x eglot-format-buffer: format the file
M-x flymake-show-buffer-diagnostics: list every error and warning

The errors appear underlined as you type, through Flymake, which is also built in. The documentation of the thing under the cursor shows up at the bottom of the screen, through ElDoc. Neither needs setup.

To start Eglot automatically, add it to the hooks of the modes you use:

(use-package eglot
:hook ((python-ts-mode go-ts-mode rust-ts-mode) . eglot-ensure)
:bind (:map eglot-mode-map
("C-c e r" . eglot-rename)
("C-c e a" . eglot-code-actions)
("C-c e f" . eglot-format-buffer)))

The :bind part gives the three most useful commands short keys, under C-c e, only when Eglot is active. And if your server isn't on Eglot's list, you add it yourself:

(with-eval-after-load 'eglot
(add-to-list 'eglot-server-programs
'(lua-mode . ("lua-language-server"))))

Tree-sitter: syntax that understands the code

Old Emacs modes highlighted code with regular expressions, which works most of the time and breaks in strange ways the rest. Tree-sitter parses the file into a real syntax tree, like a compiler would. The result is faster, more accurate highlighting and indentation, and smarter movement through the code.

Each language has a mode with -ts- in the name: python-ts-mode, go-ts-mode, rust-ts-mode, typescript-ts-mode, tsx-ts-mode, js-ts-mode, json-ts-mode, bash-ts-mode, yaml-ts-mode and many more. Each one needs a grammar, a small library for that language.

On Emacs 31, this got a lot easier. One line tells Emacs to prefer the tree-sitter modes:

(setopt treesit-enabled-modes t)

When a grammar is missing, Emacs 31 asks if you want to install it, and does the work for you. That's the default behavior, controlled by the treesit-auto-install-grammar option. Building a grammar needs a C compiler on your system, so have gcc or clang around.

On Emacs 29 and 30, it takes two steps. Install the grammar with M-x treesit-install-language-grammar, then tell Emacs to use the new mode instead of the old one:

(add-to-list 'major-mode-remap-alist '(python-mode . python-ts-mode))

People on those versions often use a package from MELPA called treesit-auto to automate this. On Emacs 31 you don't need it anymore.

Completion while you type

Completion in the minibuffer was covered in the first guide, with Vertico, Orderless and Marginalia. Completion inside the code is a separate thing, and there are two good paths.

The built-in one, since Emacs 30, is completion-preview-mode. It shows the most likely completion in gray right after the cursor, and TAB accepts it. It's quiet and light.

If you prefer the classic popup with a list of options, use Corfu, from GNU ELPA:

(use-package corfu
:ensure t
:custom (corfu-auto t)
:init (global-corfu-mode))

With corfu-auto, the list shows up on its own while you type. Eglot feeds it, so you get the same completions as any other editor using that language server.

Finding things

Programming is mostly reading, and reading is mostly searching. Consult, from GNU ELPA, gives Emacs a set of search commands with live previews:

(use-package consult
:ensure t
:bind (("C-x b" . consult-buffer)
("M-s l" . consult-line)
("M-s r" . consult-ripgrep)
("M-g i" . consult-imenu)))

• consult-buffer replaces the buffer switcher and also lists recent files and bookmarks.
• consult-line searches the lines of the current file and jumps as you move through the results.
• consult-ripgrep searches the whole project with ripgrep, so install rg first.
• consult-imenu lists every function, class and heading in the file. Without Consult, the built-in M-x imenu does the same in a simpler way.

Embark, also from GNU ELPA, is the companion. Press its key on anything, a file in a list, a symbol in the code, a search result, and it shows what you can do with it: open, rename, copy, delete, search for it. If you use Consult and Embark together, also install embark-consult, which connects the two.

(use-package embark
:ensure t
:bind ("C-." . embark-act))

C-. works in graphical Emacs. In a terminal, pick another key.

One gem in Emacs 31: search results became editable. Run M-x rgrep or M-x grep, press e in the results buffer, and edit the lines right there. Your changes go straight into the files. C-c C-c finishes. Renaming a word across forty files becomes a search and a couple of keystrokes.

Compile, test and jump to the errors

M-x compile runs any command, make, cargo build, go test ./..., npm test, and shows the output in a buffer. Error messages become links: press RET on one and Emacs opens the file at that line. C-x p c does the same from the root of the project.

M-x compile: run a build or test command
M-x recompile: run the same command again
M-g n: jump to the next error
M-g p: jump to the previous error

C-x followed by the backquote key also jumps to the next error. Set compilation-scroll-output to 'first-error and the output stops scrolling at the first problem, which is usually the one you want to read.

Running code interactively

Many languages have a REPL integration. Python is a good example of how they work:

C-c C-p: start a Python shell (run-python)
C-c C-c: send the whole file to it
C-c C-z: jump between the code and the shell

The same idea exists for Lisp, Ruby, Scheme, shell scripts and others. Write some code, send it, look at the result, adjust. It's a different rhythm from save and run, and a pleasant one.

Debugging

For C, C++ and other languages GDB understands, Emacs has a full interface built in. Run M-x gdb, then M-x gdb-many-windows, and you get the source, the variables, the stack, the breakpoints and the GDB console laid out together.

For everything else, there's Dape, from GNU ELPA. It speaks the Debug Adapter Protocol, the same one VS Code uses for its debugger, so it works with debugpy for Python, delve for Go, codelldb for Rust and C++, and the JavaScript debuggers. Install the adapter for your language, run M-x dape and choose a configuration.

Git, besides Magit

Magit is still the star, and the first guide covers it. But Emacs also has a built-in version control interface, VC, which works with Git, Mercurial and others, and has quick keys for small jobs:

C-x v v: do the next logical thing (add a new file, commit changes)
C-x v =: diff of the current file
C-x v D: diff of the whole repository
C-x v l: log of the current file
C-x v g: who wrote each line (blame)

When a merge goes wrong, open the file with conflicts and Emacs turns on smerge-mode by itself. Its commands live under C-c ^: C-c ^ n goes to the next conflict, C-c ^ u keeps your version (the upper one), C-c ^ l keeps the other one (the lower one) and C-c ^ a keeps both.

And for a quiet reminder of what you've changed, diff-hl marks changed lines in the margin:

(use-package diff-hl
:ensure t
:init (global-diff-hl-mode))

Small helpers that add up

A few built-in modes that are worth turning on in code buffers:

• electric-pair-mode closes brackets and quotes for you.
• subword-mode makes M-f and M-b stop inside camelCase words.
• hs-minor-mode folds functions and blocks. Its keys live under C-c @, and C-c @ C-h hides the block you're in.
• which-function-mode shows the name of the current function in the mode line.
• whitespace-mode shows tabs and trailing spaces, for when the linter complains about something invisible.
• display-line-numbers-mode, with display-line-numbers-type set to 'relative if you like counting jumps.
• editorconfig-mode, built in since Emacs 30, follows the .editorconfig file that many projects have, so your indentation matches the team's.

Turning them on for every programming mode is one hook each:

(add-hook 'prog-mode-hook #'display-line-numbers-mode)
(add-hook 'prog-mode-hook #'hs-minor-mode)
(add-hook 'prog-mode-hook #'subword-mode)
(add-hook 'prog-mode-hook #'electric-pair-local-mode)
(editorconfig-mode 1) ; Emacs 30 and newer

For snippets, the classic package is YASnippet, from GNU ELPA. Emacs also ships simpler tools for the same job, like abbrevs: M-x define-global-abbrev, type a short word and its expansion, and it expands as you type once abbrev-mode is on.

Code inside containers

TRAMP, which the first guide used for SSH, also opens files inside containers since Emacs 29:

/docker:container-name:/app/main.py
/podman:container-name:/app/main.py

Dired, shells and M-x compile all work in those paths, so you can browse and build inside a container without leaving Emacs.

Putting it together

Here's the programming part of a config, in one block, ready to paste after the config from the first guide:

;;; Programming

(use-package eglot
:hook ((python-ts-mode go-ts-mode rust-ts-mode) . eglot-ensure)
:bind (:map eglot-mode-map
("C-c e r" . eglot-rename)
("C-c e a" . eglot-code-actions)
("C-c e f" . eglot-format-buffer)))

(use-package corfu
:ensure t
:custom (corfu-auto t)
:init (global-corfu-mode))

(use-package consult
:ensure t
:bind (("C-x b" . consult-buffer)
("M-s l" . consult-line)
("M-s r" . consult-ripgrep)
("M-g i" . consult-imenu)))

(use-package embark
:ensure t
:bind ("C-." . embark-act))

(use-package embark-consult
:ensure t)

(use-package diff-hl
:ensure t
:init (global-diff-hl-mode))

(setq compilation-scroll-output 'first-error)

(add-hook 'prog-mode-hook #'display-line-numbers-mode)
(add-hook 'prog-mode-hook #'hs-minor-mode)
(add-hook 'prog-mode-hook #'subword-mode)
(add-hook 'prog-mode-hook #'electric-pair-local-mode)

;; Emacs 30 and newer
(editorconfig-mode 1)

;; Emacs 31: prefer tree-sitter modes and offer to install grammars
(setopt treesit-enabled-modes t)

On Emacs 29, remove the editorconfig line. On Emacs 29 and 30, remove the tree-sitter line at the end and use major-mode-remap-alist for tree-sitter, as shown above. As always, select the block and press TAB to let Emacs indent it nicely.

A sane way to adopt all this

Don't paste everything on a Monday morning before a deadline. Add one piece at a time, in this order: projects, then Eglot, then the search commands, then the rest. Live with each one for a few days. The pieces you actually use will stick, and the ones you don't can go.

This is part III of a series. Part I is about living inside Emacs: feeds, gopher, the fediverse, chat and mail. Part II teaches enough Emacs Lisp to bend all of this to your taste.

If you've never seen it, picture faces and bodies made of horizontal lines of light, usually an electric blue, that bend, stretch and come apart as if the signal were failing. It looks like a 90s television in its last good minutes, still showing something beautiful.

Veni, vidi, glitchi

POLYGON1993 is a French visual artist, film director and media scenographer based in Paris. His Tumblr sums him up in three words: "Veni, vidi, glitchi."

It started with music. In a 2021 interview, he explained that in 2015 he was composing songs that were "very glitchesque" and wanted visuals with the same intensity. As a kid of the 90s he was already drawn to the look of VHS, and when he found analog glitch art, he decided to try it himself.

A television in the middle of everything

What makes his work different from a filter is the hardware. He works with CRT televisions and circuit-bent video equipment from the 80s and 90s. Circuit bending means opening an electronic device and rewiring it on purpose, so it makes errors it was never designed to make. Any image he sends through that chain, a photo, a video or a drawing, comes out the other side distorted by the machines, and he recomposes the result into a finished piece. These days the process mixes photography, illustration and animation with the analog gear.

The screen matters as much as the circuits. About the colors of a CRT, he said in the same interview: "you just can't emulate this."

His early portraits show the idea at its most direct. When he shared a series of analog glitch portraits in 2018, he described the work as "traditional portrait art crashing into a hard and corrupted analog circuit-bent imagery."

Nostalgia, and what's under it

The obvious theme is nostalgia, but he goes further when he talks about it. In a 2024 interview with OpenSea, he listed the themes he keeps coming back to: nostalgia, depression, loneliness, "but also beauty in the breakdown." In 2021 he put it this way: "I guess I'm chasing this residual image of myself spending countless hours in front a screen when I was a kid."

That childhood shows everywhere. He grew up with trading cards, video games and MMORPGs, and he still collects Japanese arcade games, trading cards and consoles from the 90s and 2000s. Japanese pop culture runs through the work, from mecha suits to direct nods to Neon Genesis Evangelion and Ghost in the Shell. He also says the colors in his pieces come from the music he listens to while working.

Music, brands and a tour that stopped

His work as a scenographer and director has put those visuals on stages and in music videos. He has worked with Tame Impala, Charli XCX, Grimes and A$AP Rocky, and with companies like Bandai Namco, Pantone, Sony Music and Warner Music.

One of those jobs didn't go as planned. In early 2020 he was working as a content artist on Tame Impala's new live show, and the tour stopped in March because of the pandemic. With the shows on hold, he started selling limited edition holographic prints, a way to bring the work into the physical world, which he says he had always wanted.

On-chain

Around the same time, his work found a second home on the blockchain. He has released pieces on Tezos, back in the hic et nunc days, and on Ethereum through platforms like SuperRare and Foundation. In 2024 he dropped The Dance Lesson on Base, and explained to OpenSea that he chose that network for its free mints and "almost non-existent gas fees", which make the work easier to collect. Some of his drops also have game mechanics, like burning one piece to redeem another.

In 2021, he was already blunt about Instagram's algorithm, which he said was "slowly killing every artist's fire", and he hoped this new space would "take the power back from the algorithms." Instagram, at least, was never very kind to either of us.

Some of his series:

azure, light pulled sideways out of a face, as if the signal were being dragged off the screen:

Broken Wings, a small chrome figure under a sky that cracks like glass:

Panzer Perfume, where the anime and mecha side of his work comes out, with a pilot dissolving into pixels:

And First Flight, a single piece with a figure curled up inside a spiral of light and stars:

From the screen to the room

The holographic prints were only the beginning. His work now includes canvases, collectible objects, plexiglass sculptures and large installations, and it has been shown in the United States, Japan, France, the United Kingdom, Portugal, Italy and South Korea.

In 2025 he had a solo show in Tokyo, Paradigm Shifters, at The Harmonyst gallery in Hiroo. And in July 2026 he finally had his first solo exhibition in France, in his own city. Koi No Yokan opened at ArtVerse gallery in Paris, timed with Japan Expo. The title comes from a Japanese expression for the certainty, when you meet someone, that you're going to fall in love with them.

The show brought together around fifteen works: acrylic sculptures, canvas prints and rooms built around light, with holographic materials borrowed from trading card games. Among them was his first plexiglass sculpture, REI, based on an animated piece he made a few years ago. The highlight was a collaboration with Mitsuhiro Arita, one of the first illustrators of the Pokémon trading card game, whose work had never been shown in a contemporary art gallery before.

Where to follow him

His main channel, he told OpenSea, is X, where he's @Polygon1993. His series are collected on Verse, and he also has pages on SuperRare and objkt, plus a Tumblr.

On Instagram he's @polygon1993. Try not to get banned.

Underneath all of that, the original web is still there and still works the same way. Anyone can get a domain, put an HTML file on a server, and anyone else in the world can read it with a browser, no account needed. A lot of people never stopped doing that. Two names keep coming up when people talk about them: the IndieWeb and the small web. They overlap a lot, and they aren't the same thing, so here's what each one means, what it looks like in practice and how to get in.

The IndieWeb

The IndieWeb describes itself as "a people-focused alternative to the corporate web": a community of independent and personal websites built around a few ideas. You own your domain and use it as your main identity online. You publish on your own site first, and only then, if you want, somewhere else. And you own what you write.

It has a home at indieweb.org, a wiki that is also its documentation, and a history of meetups. The earliest IndieWebCamp on the wiki's list happened in Portland, Oregon, in 2011, and there are still small online and local gatherings for people who are building their own sites.

The community keeps a list of principles. Some are what you'd expect: own your domain and data, use what you make, make your code open source, build for the long web. Others are a little more surprising, like "Make what you need" (for yourself first, not for "everyone") and "Pluralism", which means there's no single right way or software to do any of this. The last one closes the list: "Above all, Have fun. Keep the web weird and interesting."

POSSE

The idea people bring up most is POSSE: Publish (on your) Own Site, Syndicate Elsewhere. You write the post on your site, at your address, and then share a copy or a link on Mastodon, Bluesky or wherever your friends are. If the platform disappears, changes its rules or locks you out, the original is still at your address. The links you shared over the years keep working, because they point to you.

The building blocks

Owning a site is the easy part. The interesting work is making independent sites talk to each other the way social networks do, with replies, likes and follows, but without a company in the middle. The IndieWeb uses a handful of small standards for that, and none of them needs more than ordinary HTML and HTTP:

• Microformats are plain class names you add to your HTML so software can read it. An h-card says who you are (name, photo, URL), an h-entry marks a post, with its title, date and content. Your page looks exactly the same to people.
• rel="me" links connect your site to your other profiles. If your site links to your GitHub with rel="me" and your GitHub links back to your site, that's proof both belong to the same person. Mastodon uses the same trick to show a verified link on your profile.
• Webmention is how sites notify each other. When you write a reply on your blog to a post on someone else's blog, your site sends a small notice to theirs saying "this page mentions you". Their site can then show your reply as a comment. It became a W3C Recommendation in January 2017.
• IndieAuth lets you sign in to services using your own domain as your identity, instead of a Google or Facebook account.
• Micropub lets you publish to your site from other apps, like a phone app for quick notes or photos. It became a W3C Recommendation in May 2017.

You don't need all of them. Most IndieWeb sites start with a domain, an h-card and a few rel="me" links, and add the rest over time.

What that looks like on this blog

This blog runs on PaCord, my own CMS, and it speaks most of that language. If you open the source of the home page, among the usual tags in the <head>, there are lines like these:

<link rel="webmention" href="https://cms.pablomurad.com/webmention">
<link rel="micropub" href="https://cms.pablomurad.com/micropub">
<link rel="authorization_endpoint" href="https://cms.pablomurad.com/indieauth/auth">
<link rel="token_endpoint" href="https://cms.pablomurad.com/indieauth/token">

Those tell other software where to send webmentions, where a Micropub app can post, and how to sign in with pablomurad.com through IndieAuth. Further down, the page has an h-card with my name and photo, every post is marked as an h-entry, and the footer links to my other profiles with rel="me": GitHub, Codeberg, sourcehut, my own Git server and murad.social, among others. There are feeds too, in RSS, Atom, JSON Feed and JF2, so any reader can follow along.

The easiest way to check your own site is IndieWebify.me, which walks you through each step and tests your pages. This is what it finds here:

The small web

The small web is harder to pin down, because nobody owns the term. There's no wiki that defines it, no list of principles and no standard to implement. It's a loose name for the part of the internet made of personal, non-commercial, usually lightweight sites, made by one person or a few, because they wanted that thing to exist.

Where the IndieWeb talks about protocols and ownership, the small web is about scale and feel. A small web site is usually:

• personal: a homepage, a blog, a fan shrine, a collection of recipes, a page about one strange hobby;
• light: plain HTML, a little CSS, few or no scripts, no trackers and no cookie banners;
• made by hand, or close to it, often with the seams showing;
• connected in old ways: links to friends, webrings, blogrolls, guestbooks, RSS, and those tiny 88x31 buttons from the 2000s.

Some people take the "small" literally. The 512KB Club and the 1MB Club, which showed up in Neat Finds #02, only list sites whose pages weigh less than that.

The small web also goes beyond HTTP. Gemini is a protocol made in 2019 to be deliberately simpler than the web, with text pages and no scripts at all. Gopher, from 1991, still has people writing phlogs on it. Nex is even smaller: you connect, send a path and get back text. And there are pubnixes, or tildes, shared Unix servers where members get a shell account, a home page at /~name and a community that talks through the terminal.

Where it lives

A lot of the small web lives on Neocities, a free host for static sites that took the place GeoCities left empty. You get yourname.neocities.org, an editor in the browser and a community where sites follow each other. The counter on its home page shows more than 1.8 million sites.

The rest is spread across personal domains, cheap shared hosting, home servers, Raspberry Pis on a shelf, pubnixes and Gemini capsules.

How to find it

You won't find much of it through the big search engines or social feeds, which favor large commercial sites. A few tools are made for this.

Kagi Small Web shows you recent posts from personal blogs, independent video channels and webcomics, one at a time. You press "Next Post" and land on someone's site, with a thin toolbar on top. It's free to use, and the list of sources is open on GitHub.

Marginalia Search is an independent search engine that puts non-commercial, text-heavy sites first and helps you find old websites the big engines forgot. It's open source, and it doesn't share your data or keep your IP address for long.

Then there are the old ways, which still work. Webrings, where every site links to the next one in a loop. Directories made by people instead of algorithms. And the links page on the sites you already like: one personal site almost always leads to five more.

Same neighborhood, different streets

A Neocities shrine to a 90s cartoon, with a guestbook and a hit counter, is pure small web, and it doesn't need a single microformat. A developer's blog with Webmention, IndieAuth and a Micropub app is IndieWeb, even if it's built on a big framework and isn't small at all. Many sites are both, and nobody is checking.

What they share is the starting point: a person with their own address, publishing for other people, with no platform deciding who gets to see it.

My corners of it

Besides this blog, a few of my projects live in this neighborhood.

weirdnet is a directory of the small and personal web, organized by hand. It has more than 50,000 links across 314 categories, from personal sites and archives to webrings, amateur radio and the 512KB Club, plus a random button that sends you somewhere unexpected. If you know a site that belongs there, the suggestion page explains how to send it. There's also a short guide on starting your own site.

phlog.space is a small, free photo log, written in plain PHP with SQLite and no JavaScript. Soledade is a blog in Portuguese shaped like a little town, which you can also read from a terminal over a Nex-style port. runv.club is a pubnix, and noctem.cafe and noctem9.cafe are two more I look after. And if you want to build a site by hand, Pablo, how? has a seven-part series called Web by hand that goes from an empty folder to a styled site with its own RSS feed, and Docs do Murad has the same kind of material in Portuguese.

How to start

You don't need permission or a framework. A reasonable path:

1. Get a place to live. A domain of your own is the IndieWeb way, and it keeps your address yours forever. A free Neocities page is the fastest way to start today, and you can point a domain at it later.
2. Write one page by hand: who you are, what you like, a few links. It can be ugly. Plenty of sites start like that.
3. Add an h-card to that page and rel="me" links to your other profiles. Ten minutes of work, and IndieWebify.me will tell you if it's right.
4. Start a feed, even if you only post once a month. RSS is still how most people on the small web follow each other.
5. Go out and meet the neighbors. Join a webring, sign a few guestbooks, add a links page, and send your site to directories.

From there, add whatever you feel like: webmentions, a guestbook, a Gemini mirror, an 88x31 button. Your site will change over the years, and it will still be at the same address.

That protocol is WebFinger. It's small, it has been around since 2013, and a lot of the fediverse depends on it. This post explains what it is, how a request and an answer look, who uses it, and how to set it up on your own domain, from a single static file to a short script that follows the spec properly.

Where the name comes from

Long before the web, Unix systems had finger. You typed finger user@host and the other machine told you who that person was, when they last logged in, and whatever they wrote in their .plan file. The first spec, RFC 742, is from 1977. (Finger.Farm, from Neat Finds #04, still hosts finger accounts today.)

WebFinger takes the same idea to HTTPS. You ask a domain about an identifier, usually something that looks like an email address, and the domain answers with a JSON document full of links: where the profile is, where the avatar is, which server handles the account. It's RFC 7033, published in September 2013 as a Proposed Standard. The project's home is webfinger.net, with the spec, a list of code and the link relations it registers.

One request, one answer

Every WebFinger request goes to the same path on the domain, /.well-known/webfinger, with a resource parameter saying who or what you're asking about. You can try it with curl:

curl -s "https://pablomurad.com/.well-known/webfinger?resource=acct:pablo@pablomurad.com"

This is what comes back (formatted here, one item per line):

{
"subject": "acct:pablo@murad.social",
"aliases": [
"https://murad.social/users/pablo",
"https://murad.social/@pablo"
],
"links": [
{
"rel": "http://webfinger.net/rel/profile-page",
"type": "text/html",
"href": "https://murad.social/@pablo"
},
{
"rel": "self",
"type": "application/activity+json",
"href": "https://murad.social/users/pablo"
}
]
}

A few things to notice in the request. acct: is a URI scheme made for accounts, defined later in RFC 7565. It looks like an email address, but nothing says there has to be a mailbox behind it. The resource can also be any other URI, like https://pablomurad.com/ or a mailto: address, as long as the server knows what to do with it.

The answer is a JRD, short for JSON Resource Descriptor, and it's sent with the content type application/jrd+json. It has four possible members:

• subject is the URI the document describes. The RFC says it SHOULD be there.
• aliases is a list of other URIs for the same thing.
• properties holds extra facts about the subject, as name and value pairs where each name is a URI.
• links is where most of the work happens. Each link has a rel (the only required field, saying what kind of link it is), and optionally a type, an href, titles in different languages and its own properties.

Look at the subject in the answer above: the question was about acct:pablo@pablomurad.com and the answer is about acct:pablo@murad.social. That's allowed, and it's the reason the trick works. Mastodon's docs explain what happens next: when the subject differs from what was asked, Mastodon makes a second WebFinger request to the domain in the subject, checks that it points to the same account, and goes with that.

The rules in the spec

RFC 7033 is short, and the rules a server has to follow fit in a list:

• HTTPS only. Clients must query over HTTPS, and the resource must not be served over plain HTTP. Redirects are allowed, but only to another https address.
• The query must have a resource parameter. If it's missing or malformed, the answer is 400 Bad Request.
• If the server doesn't know the resource, the answer is 404.
• Responses must carry the Access-Control-Allow-Origin header, so code running in a browser can read them. In practice that's Access-Control-Allow-Origin: *.
• Servers should support the rel parameter. A client can send one or more rel values, and the server returns only the links that match. The subject, aliases and properties come back either way.
• Clients must ignore any member of the JRD they don't understand. That's what lets you add your own fields without breaking anyone.

Who asks these questions

The fediverse is the biggest user. When you search for @someone@example.com on Mastodon, GoToSocial or most other servers, the first thing they do is ask example.com over WebFinger. Mastodon's documentation lists the links it cares about:

• self, with type application/activity+json, pointing to the ActivityPub actor. This is the link Mastodon really needs. A minimal valid answer for Mastodon is a subject plus this one link.
• http://webfinger.net/rel/profile-page, the HTML profile a person would open in a browser.
• http://ostatus.org/schema/1.0/subscribe, with a template field instead of href. Other servers use it to send you to your own instance to follow someone.

OpenID Connect uses WebFinger to find the identity provider for an address. The link has rel set to http://openid.net/specs/connect/1.0/issuer and its href is the issuer URL. The RFC's own first example is exactly this, and services use it in the wild: Tailscale, when you sign up with a custom OIDC provider, asks the domain of your email address over WebFinger and expects that issuer link back, matching the issuer in your provider's /.well-known/openid-configuration.

webfinger.net also keeps a small list of its own link relations. There are two: http://webfinger.net/rel/avatar for a picture and http://webfinger.net/rel/profile-page for the main page about the account.

Setting it up

There are three ways to do this, from quickest to most correct. Pick the one that fits how many people live on your domain.

One note on the code below: it's written flat, with no indentation, because this blog's editor collapses repeated spaces. nginx, Caddy and PHP don't care.

One static file

This is the fastest way to make you@yourdomain find your fediverse account. Start by saving the answer your own server already gives (swap in your handle and instance):

curl -s "https://murad.social/.well-known/webfinger?resource=acct:pablo@murad.social" > webfinger.json

Put webfinger.json somewhere on your web server and tell the server to answer the WebFinger path with it. On nginx, inside the server block of your domain:

location = /.well-known/webfinger {
types { }
default_type application/jrd+json;
add_header Access-Control-Allow-Origin "*" always;
alias /var/www/example.com/webfinger.json;
}

The empty types { } is there on purpose. Without it, nginx looks at the .json extension and sends application/json, which isn't the content type the spec asks for.

On Caddy, inside your site block:

handle /.well-known/webfinger {
header Content-Type application/jrd+json
header Access-Control-Allow-Origin *
rewrite * /webfinger.json
file_server
}

This assumes your site block already has a root pointing to the folder where the file lives.

Reload the server and test it. Then go to any fediverse account and search for @you@yourdomain. Your profile should show up.

There are trade-offs, and they all come from the file not reading the question:

• Every question gets the same answer. Ask about anyone@yourdomain and you get your account. Ask with no resource at all and you still get a 200 instead of the 400 the spec asks for.
• The rel filter is ignored, so clients always get every link.
• Your domain becomes a pointer, and your handle doesn't change. People can find you as @pablo@pablomurad.com, but your posts still show @pablo@murad.social, because that's the subject in the answer.

pablomurad.com answers exactly like this today: any name at this domain leads to the same account. For a domain with one person behind it, that's usually fine.

Several accounts with an nginx map

If a few people share a domain, nginx can still do it without any code. A map picks a file based on the resource parameter. The map goes in the http block, outside any server:

map $arg_resource $webfinger_file {
default "";
"acct:pablo@example.com" pablo.json;
"acct%3Apablo%40example.com" pablo.json;
"acct:ana@example.com" ana.json;
"acct%3Aana%40example.com" ana.json;
}

And the location goes inside your server:

location = /.well-known/webfinger {
if ($arg_resource = "") { return 400; }
if ($webfinger_file = "") { return 404; }
types { }
default_type application/jrd+json;
add_header Access-Control-Allow-Origin "*" always;
root /var/www/webfinger;
try_files /$webfinger_file =404;
}

Each account gets its own file in /var/www/webfinger. Now a missing resource gets a 400, an unknown name gets a 404, and each person gets their own answer.

Each account appears twice in the map because $arg_resource is the raw query string. Some clients send acct:pablo@example.com and others encode it as acct%3Apablo%40example.com, and nginx doesn't decode it for you. The map is also case-sensitive. It's fine for a handful of accounts. Past that, or if you want the rel filter, it's time for a script.

A short PHP script that follows the spec

PHP runs almost everywhere, from a VPS to cheap shared hosting, and it's enough for this. The script reads a list of accounts, each pointing to a JSON file, and handles everything the spec asks for: the 400, the 404, CORS, the right content type and the rel filter.

Save it as webfinger.php at the root of your site:

<?php
// webfinger.php: answers /.well-known/webfinger for the accounts listed below.

// Every resource you want to answer for, pointing to its JSON file.
$accounts = [
'acct:pablo@example.com' => __DIR__ . '/webfinger/pablo.json',
'https://example.com/' => __DIR__ . '/webfinger/pablo.json',
];

// Any web page may read this, so CORS is open (RFC 7033 asks for it).
header('Access-Control-Allow-Origin: *');

// Read the query by hand: PHP keeps only the last "rel" if there are several.
$resource = '';
$rels = [];
foreach (explode('&', $_SERVER['QUERY_STRING'] ?? '') as $pair) {
[$key, $value] = array_pad(explode('=', $pair, 2), 2, '');
$value = urldecode($value);
if ($key === 'resource') { $resource = $value; }
if ($key === 'rel') { $rels[] = $value; }
}

// No resource at all: a bad request.
if ($resource === '') {
http_response_code(400);
exit("Missing resource parameter\n");
}

// Nobody by that name here.
if (!isset($accounts[$resource])) {
http_response_code(404);
exit("Not found\n");
}

$jrd = json_decode(file_get_contents($accounts[$resource]), true);

// If the client asked for specific rels, return only those links.
if ($rels && isset($jrd['links'])) {
$jrd['links'] = array_values(array_filter(
$jrd['links'],
fn($link) => in_array($link['rel'] ?? '', $rels, true)
));
}

header('Content-Type: application/jrd+json');
echo json_encode($jrd, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT), "\n";

The JSON files go in a webfinger/ folder next to it, one per person, written by hand or copied from your fediverse server like before. The second line in $accounts shows that a resource doesn't have to be an acct:. Here, asking about the homepage leads to the same person.

The part people trip on is the query string. PHP builds $_GET with the last value of each name, so rel=self&rel=avatar would turn into just avatar. Parsing QUERY_STRING by hand keeps both. The arrow function needs PHP 7.4 or newer.

Now point the WebFinger path at the script. On nginx with PHP-FPM:

location = /.well-known/webfinger {
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME /var/www/example.com/webfinger.php;
fastcgi_pass unix:/run/php/php8.3-fpm.sock;
}

The socket name changes with the PHP version, so check yours with ls /run/php/.

On Caddy, it's a rewrite plus the PHP handler. The query string survives the rewrite:

example.com {
root * /var/www/example.com
rewrite /.well-known/webfinger /webfinger.php
php_fastcgi unix//run/php/php8.3-fpm.sock
file_server
}

When you want the handle itself on your domain

Everything above makes your domain point to an account that lives somewhere else. If you run your own Mastodon or GoToSocial server and want the handle to be @you@yourdomain for real, while the server runs on a subdomain like social.yourdomain, both have a setting for it:

• Mastodon calls it LOCAL_DOMAIN (the domain in the handles) and WEB_DOMAIN (where the server actually runs).
• GoToSocial calls it account-domain and host.

In both cases the main domain has to redirect WebFinger to the server. GoToSocial also wants /.well-known/host-meta and /.well-known/nodeinfo redirected. This is the Caddy version from the GoToSocial docs, on the main domain:

example.com {
redir /.well-known/host-meta* https://social.example.com{uri} permanent
redir /.well-known/webfinger* https://social.example.com{uri} permanent
redir /.well-known/nodeinfo* https://social.example.com{uri} permanent
}

Mastodon's docs add that this redirect needs CORS headers too, or parts of the web interface break.

This has to be decided before the first start. Both projects say the same thing in their docs: once your server has federated with others, the domain layout can't be safely changed, because remote servers cache the mapping and get confused. If you already have an account somewhere and only want a nicer address, the static file is the safer path.

Making it yours

Since clients ignore what they don't understand, the JRD is a good place to collect your links. Some ideas:

• An avatar, with rel set to http://webfinger.net/rel/avatar and the image's type.
• A profile page pointing to your blog instead of your fediverse profile.
• titles, so a link can carry a name in more than one language, like {"en": "My blog", "pt-BR": "Meu blog"}.
• An OpenID Connect issuer link, if you run your own identity provider. Pocket ID, from the first Neat Finds, is one.
• Your own link types. A rel can be any URI, so you can make one up under your domain, like https://example.com/rel/feed with type set to application/atom+xml for your blog's feed.
• properties, also named by URIs, for small facts like your display name.

For a full example, look at packetizer.com, home of one of the RFC's authors. His address there returns properties with his name in English and Chinese and the date the account was created, plus links to an avatar, a profile page, his blog with a title, a vCard, his blog's Atom feed and an OpenID provider:

curl -s "https://packetizer.com/.well-known/webfinger?resource=acct:paulej@packetizer.com"

Here's what a personal JRD with a few of those ideas could look like. The example.com names are placeholders:

{
"subject": "acct:pablo@example.com",
"aliases": ["https://example.com/"],
"properties": {
"https://example.com/ns/name": "Pablo"
},
"links": [
{"rel": "self", "type": "application/activity+json", "href": "https://social.example.net/users/pablo"},
{"rel": "http://webfinger.net/rel/profile-page", "type": "text/html", "href": "https://example.com/"},
{"rel": "http://webfinger.net/rel/avatar", "type": "image/png", "href": "https://example.com/avatar.png"},
{"rel": "https://example.com/rel/feed", "type": "application/atom+xml", "href": "https://example.com/feed.xml", "titles": {"en": "Blog", "pt-BR": "Blog"}}
]
}

Testing it

curl with -i shows the headers, which is where most mistakes hide:

curl -si "https://example.com/.well-known/webfinger?resource=acct:pablo@example.com"

Check the status (200), Content-Type: application/jrd+json and Access-Control-Allow-Origin: *. Then try the edge cases:

curl -s -o /dev/null -w "%{http_code}\n" "https://example.com/.well-known/webfinger"
curl -s -o /dev/null -w "%{http_code}\n" "https://example.com/.well-known/webfinger?resource=acct:nobody@example.com"
curl -s "https://example.com/.well-known/webfinger?resource=acct:pablo@example.com&rel=self" | jq ".links[].rel"

The first should print 400, the second 404, and the third only "self". With the static file, all three give you the full answer, as described above. The final test is the human one: search for the address from a fediverse account and see if your profile shows up.

What you're publishing

Everything in that JSON is public, and the open CORS header means any web page can read it with a line of JavaScript. RFC 7033 is explicit about this: WebFinger must not be used to publish personal data unless the person explicitly agreed, and a service that publishes data about its users must let them choose what goes out. If you're answering for other people, ask them what they want in their file.

Keep phone numbers and private email addresses out of it unless you want them collected. And if you run a server for many accounts, the RFC recommends taking steps against abuse, since a 404 for unknown names and a 200 for real ones is enough to check, one request at a time, who has an account.

Same deal as always: I haven't tested everything here, and the last lines of each entry are what I'd be tempted to build, not promises.

01. HN Personal Websites Directory

github.com/hnpwd/hnpwd

A community-maintained directory of personal websites by people from Hacker News, published at hnpwd.github.io together with an OPML file of all their RSS feeds. The criteria are clear: the site has to belong to one person, have a good amount of English content and be fully under the author's control, and purely AI-generated content is out. You add a site with a pull request or an issue. Importing that OPML into a feed reader gives you a lot of reading in one click.

02. BUKMARK.CLUB

github.com/ttntm/bukmark.club

A directory of websites that keep a curated collection of bookmarks or links to other sites. That's the whole requirement for a listing. You fork the repo, add a Markdown file with your site's details, optionally with your own 88x31 button, and open a pull request. The lists on pablo.how, with pubnixes and Gemini capsules worth a visit, look like the kind of page this club collects.

03. ringfairy

github.com/k3rs3d/ringfairy

A webring generator in Rust, built like a static site generator made only for webrings. It writes plain HTML redirects, with no server code at all, so the whole ring can live on Neocities or GitHub Pages. It checks that every member site actually carries the ring's links, uses templates for everything and builds an OPML file of the members that have RSS. The trade-off is that every change means regenerating the ring, which the README says is quick. A ring for the handful of small sites I run would be an easy first test.

04. The Repository for 88x31 Buttons

github.com/transicle/88x31

An automatically updated collection of 88x31 buttons, the tiny banners of the 2000s web. The latest sync lists 86,882 unique buttons spread over 173 gallery pages, and new ones show up on their own when a site with buttons is added to the list. Good for finding a button to link to, or for scrolling through the old web's tiny ads for an hour. phlog.space has an 88x31 button of its own, and it would be fun to see it turn up in there one day.

05. PuppyPad

github.com/DeRusto/puppypad

"A free old-web homepage host. Accidents welcome." Every member gets a subdomain for a static site, with a file manager, an in-browser editor, a hit counter, a guestbook and a webring link. There are four starter layouts, a style editor for colors, fonts, borders and even the cursor, and an upload option that shrinks big photos and strips their camera details. The public instance is at puppypad.org, and since the code is AGPL you can run your own, with quotas set in a config file. One of these for a small group of friends would be a good use for a spare VPS.

06. mataroa

github.com/mataroablog/mataroa

"Naked blogging platform." Text only, with no themes, no custom CSS and no tags. Signing up takes a minute and doesn't ask for an email address, posts are Markdown, and there are no ads and no tracking. You can export the whole blog whenever you want, including as Zola or Hugo source files or as an epub, and it also mails you an export every month. The hosted version at mataroa.blog has a free plan and a paid one that adds your own domain and posting by email. The epub export is a lovely idea: a blog that becomes a book you can read on an e-reader.

07. ttbp

github.com/modgethanc/ttbp

The tilde.town blogging platform, a command-line hub for writing and reading blog posts on that server. You log in, type feels, and you can write your own entries and read what other residents wrote, a bit like LiveJournal living in a terminal. Each entry can go to a public page on your tilde, to tilde.town's gopher server, or stay private on the server. Something like this would sit well on runv.club.

08. burrow

github.com/jamestomasino/burrow

A helper for building and managing a gopher hole. burrow phlog asks for a title and opens a new post in your editor, burrow gophermap lets you edit a gophermap while writing the comments in plain text, and burrow rss builds a feed of your latest phlog posts. It can also pull, commit and push your gopher folder with git, which makes it easy to run from cron. The default config points at SDF, which tells you where it grew up. For anyone keeping a phlog on a pubnix, it saves a lot of typing.

09. Nexy

github.com/YGGverse/nexy

A server for the Nex protocol, written in Rust. Nex is about as small as a protocol gets: you connect, send a path, and get back a document or a directory listing. Nexy can listen on the regular internet and on networks like Yggdrasil and Mycelium at the same time, has templates for directory listings and other responses, and writes its access log in the Common Log Format, so GoAccess can read it. Soledade's reading port, 1900, already answers Nex-style requests, so Nexy is a good reference to compare against.

10. cozy

github.com/hachiya-kurisu/cozy

"surf the small web": a terminal browser for Gemini, Spartan and Nex, written in Go. Install it with go install, run cozy, or pass an address to go straight there, like cozy nex://manatsu.town/. cozy -t day forces the day theme. The plans in the README are client certificates, maybe images in the terminal, and "aesthetics". Pointing it at Soledade over Nex is the obvious first test.

11. Kennedy

github.com/acidus99/Kennedy

A search engine for Gemini space, with its own crawler, backend and Gemini app server, built on ideas from the early web's crawlers and search engines. It does full-text search with stemming, suggests other queries when you get few results, understands searches like "cats AND dogs", and even searches images by their link text and paths. Try it at gemini://kennedy.gemi.dev, or through an HTTP proxy if you don't have a Gemini browser yet. With cozy from the entry above, that's a small-web setup in two programs.

12. Cerca

github.com/cblgh/cerca

"Lean forum software", written to power the Merveilles community forums. The README talks about missing the forums of the mid noughties: long discussions you visit on your own time, without being notified in the middle of something else. Threads can be public or private, invites come in one-time and multi-use batches, admin actions show up in a moderation log anyone logged in can read, and the big decisions need two admins or a week without a veto. There's RSS for new threads and posts. A small forum for the people who read this blog would be a fun experiment.

13. Joker CGI Guestbook

github.com/dbohdan/joker-cgi-guestbook

A toy old-school CGI guestbook written in Joker, a dialect of Clojure. It's one self-contained script with the settings at the top, like CGI scripts used to have, and it keeps the entries in a Bolt database. Captchas are stateless and signed with HMAC. There's no admin page at all: to hide an entry, you open the database and add "hide": true to its JSON. It was written for the SDF Public Access UNIX System, and the author says plainly that it's a toy. phlog.space has guestbooks too, so this one is good to read side by side.

14. QR-Server

github.com/Xelckis/qr-server

"A Full Web Server Inside a QR Code." A Linux web server written in x86_64 assembly, with a Brotli-compressed HTML page baked into the binary, and the whole thing weighs under 3 KB and fits in a single Version 40 QR code. It comes with an extractor in Go that reads the binary back out of the image without corrupting it. The README calls it "the peak of Jank Engineering", which is fair. That QR code printed on a business card would be the strangest homepage link around.

15. Outis

github.com/dtonon/outis

A small Go tool that answers spam with a fake "user unknown" bounce, so the sender believes your address doesn't exist. The bounce is modeled on a real Postfix one, following RFC 3464, and goes out from MAILER-DAEMON with a null sender when your server allows it. The name is Greek for "nobody", the name Odysseus gives the Cyclops. The README is honest about the limits: the message was already accepted, so it only works on senders that actually process bounces, and it's only believable when it comes from a domain you control. With your own domain and an SMTP account that can send as MAILER-DAEMON, it's a cheeky tool to keep around.

16. WBTV

github.com/WB2024/WBTV

Turns your own media library into live TV. You point it at your folders and it builds the channels and an EPG-style guide by itself, using the NFO tags in your library. Then come the details that make it feel like broadcast television: retro ad breaks, station idents, "coming up next" announcements read by a voice generated offline on your own machine, and a test card for the overnight closedown. It runs in one Docker container with your media mounted read-only, and there's an Android TV app. I've written about running a 24/7 TV channel from home, so the idents and the test card are the first things I'd look at.

17. NESty

github.com/delacannon/nesty

A Bitsy-style editor for making real NES games. You draw rooms, tiles, sprites and dialogs in the browser, and NESty compiles the game to 6502 assembly, assembles it into an iNES ROM right there and lets you play-test it in an embedded emulator. You can download the .nes file for any emulator or flash cart, and the generated .asm to study. Like Bitsy, the games are about walking around, talking to people and picking things up, one screen per room, with the console's real limits checked as you go. It's live at nesy.netlify.app. A tiny game set in Soledade, with the church tower and the lit windows, would make a good first cartridge.

18. CyberCity

github.com/MiguelCarino/CyberCity

Four walkable worlds drawn entirely in text characters: a rain-lit cyberpunk city, an 1880s frontier town, the Moon in the Apollo era and an Edo castle town on a wet evening. It's one HTML page and three small scripts, with no build step and no dependencies, and the sun goes round. All four worlds share the same engine and the same seed, so pressing 1, 2, 3 and 4 shows the same corner of the same street in four different places. The README goes deep into how each world is lit, and it's worth reading even if you never touch the code. Walk around at cybercity.carino.systems.

19. Jangada

github.com/zednaked/jangada

Alternative firmware for the M-VAVE FM-1, a pocket synth of about €70, "with a dark, industrial and Brazilian accent." Thirteen synth engines, four tracks, a modulation matrix, drones that evolve on their own, and drum kits that bring in maracatu, baião and coco, with alfaia, zabumba and cuíca. It's a fork of Felucca, and the name plays on that: a felucca is a Nile sailboat, a jangada is the Brazilian one. You can play it in the browser before flashing anything, and the README says the FM-1's boot area is never touched, so the official firmware is always one step away. Manguebeat on a pocket synth is reason enough to buy the hardware.

20. esp32flight

github.com/theqkash/esp32flight

A desk flight radar on a single ESP32 board with a touchscreen, also available as an Android app built from the same code. It lists the aircraft around you with airline logos, routes, altitude and speed, tells you which way to look and when a plane will pass over, and has a retro CRT radar view. The data comes from free community ADS-B sources or from your own receiver on the network, and it can also show the ISS, weather balloons and ships. You install it from the browser, and the cheapest supported board costs around $15. The README currently warns that the optional FlightAware integration has a bug that burns API credits, so leave that key empty. A little screen like that by a window, watching the sky, sounds like a good weekend.

Bonus tabs

A few more I refuse to close:

Devzat · An SSH server that drops you into a chat room instead of a shell. Try ssh devzat.hackclub.com.

Oddmuse · A wiki engine in a single Perl script, with no database.

NESFab · A programming language made just for NES games, if NESty leaves you wanting more.

photoc · Command-line tools for photographers: find blurry shots and duplicates, make contact sheets, strip GPS before sharing.

Bookshelf · A home screen for KOReader, with covers, lists or spines standing like a real bookcase.

Owly · AirDrop between iPhones and Linux, on supported Wi-Fi hardware.

dnsglobe · Watch a DNS record propagate across 34 public resolvers on a world map, in your terminal.

magick.css · A classless CSS file inspired by LaTeX and old tabletop RPG rulebooks.

That's issue five. Most of it is about places where people put their own words, and the rest makes noise or lights up a desk.

Found a strange repository, a forgotten tool or a small piece of software I should see? Send it my way. Reader suggestions are welcome for issue six. And if you make something with any of these, I'd like to see it.

Happy wandering!
Pablo

The goal is small and practical. By the end you'll read Lisp without panicking, write your own commands, give them keys, hook them into modes and know how to dig into any function Emacs has. That's most of what people ever do with Elisp.

Why bother

Every key you press in Emacs runs a function written in Emacs Lisp. Your config is Lisp. The packages you install are Lisp. Once you can read a little of it, three things change:

• Your init.el stops being a list of spells copied from the internet. You know what each line does, and you can fix it when it breaks.
• When something annoys you, you can write the fix yourself, usually in five or ten lines.
• The source of every command is one click away, so Emacs becomes its own textbook.

Where to try things

You don't need to create a file to experiment. Emacs gives you three playgrounds.

The *scratch* buffer opens with Emacs, in a mode made for this. Type an expression, put the cursor right after it and press C-j. The result gets printed on the next line.

M-: asks for an expression in the minibuffer, runs it and shows the result at the bottom of the screen. It works from any buffer, which makes it great for quick questions like "what's the value of this variable right now?".

C-x C-e runs the expression right before the cursor, in any Lisp file. This is the one you'll use the most in your init.el: change a line, put the cursor after it, C-x C-e, and the change is live without restarting.

And if you like a proper REPL, M-x ielm gives you one, with a prompt and history.

Reading Lisp

Lisp looks scary because of the parentheses, but the rule is simple. A list in parentheses is a call: the first thing is the function, the rest are its arguments.

(+ 1 2) ; => 3
(* 2 (+ 3 4)) ; => 14
(concat "Hello, " "Emacs") ; => "Hello, Emacs"
(upcase "hello") ; => "HELLO"

The inner parentheses run first, so (* 2 (+ 3 4)) becomes (* 2 7), which becomes 14. That's the whole grammar. Everything else is vocabulary.

A semicolon starts a comment. Strings go in double quotes. t means true, and nil means false and also "empty list". Those two show up everywhere.

Sometimes you want a list as data, not as a call. That's what the quote is for:

'(+ 1 2) ; => (+ 1 2), just a list with three things in it
(+ 1 2) ; => 3
(car '(apples pears plums)) ; => apples, the first item
(cdr '(apples pears plums)) ; => (pears plums), the rest

The same quote is why config files are full of things like 'modus-vivendi or #'display-line-numbers-mode. The ' says "this name, as it is". The #' is the same idea for names of functions, and it helps Emacs warn you when you misspell one.

A note about indentation: Lisp doesn't care about it. The blocks of code in this post are written flat, and Emacs will indent them properly for you. Paste the code, select it and press TAB, or use C-M-\.

Variables

setq sets a variable. let creates variables that only exist inside its parentheses:

(setq my-name "Pablo")

(let ((x 10)
(y 32))
(+ x y)) ; => 42, and x and y vanish after this

format builds a string with placeholders, %s for anything and %d for whole numbers:

(format "Hi, %s! You have %d buffers open." my-name (length (buffer-list)))

For settings that Emacs or a package offers as options (the ones you'd see in M-x customize), Emacs 29 added setopt. It works like setq, but it also runs any code the option needs when it changes, and it warns you when the value has the wrong type:

(setopt fill-column 80)

A simple habit: setopt for options, setq for everything else.

Your first command

A function is made with defun. Give it a name, a list of arguments, a short description and a body. Add (interactive) and it becomes a command, something you can run with M-x or bind to a key.

(defun my-insert-date ()
"Insert today's date at point, like 2026-11-06."
(interactive)
(insert (format-time-string "%Y-%m-%d")))

Put the cursor after the last parenthesis and press C-x C-e. Now M-x my-insert-date works. And because you wrote a description, C-h f my-insert-date shows it, just like any built-in command.

Two habits worth having from day one. First, start your function names with a prefix, like my-, so they never clash with something Emacs or a package already uses. Second, always write the description. Future you will read it.

Giving it a key

Emacs 29 added a clean way to bind keys:

(keymap-global-set "C-c d" #'my-insert-date)

Now C-c d inserts the date anywhere. The choice of C-c and a letter is on purpose. Emacs keeps every C-c followed by a plain letter for you, the user. Neither Emacs nor well-behaved packages will ever take those keys, so they're the safe place for your own commands.

You can also bind a key only inside one mode, using that mode's keymap:

(with-eval-after-load 'org
(keymap-set org-mode-map "C-c n" #'my-new-note))

with-eval-after-load waits until Org is actually loaded before touching its keymap. Without it, Emacs would complain that org-mode-map doesn't exist yet. You'll write my-new-note in a minute.

Asking the user for something

interactive can do more than mark a function as a command. Give it a code and Emacs will ask the user for the arguments. "s" asks for a string:

(defun my-greet (name)
"Say hello to NAME."
(interactive "sYour name: ")
(message "Hello, %s!" name))

Run M-x my-greet and Emacs prompts "Your name:" in the minibuffer. Other codes ask for a number ("n"), a file ("f"), a buffer ("b") and more. C-h f interactive lists them all.

Working with text

Inside a buffer, the cursor position is called the point, and a few functions do most of the work:

• (point): where the cursor is, as a number.
• (goto-char 1): move the cursor. (point-min) and (point-max) are the start and the end of the buffer.
• (insert "text"): write at the cursor.
• (buffer-string): the whole buffer as a string.
• (count-words (point-min) (point-max)): count words, which is a built-in command too.

One more is worth learning early: save-excursion. It runs some code and then puts the cursor back where it was, so your command doesn't leave the user lost in the file.

(defun my-add-todo-on-top ()
"Insert a TODO line at the top of the buffer, without moving the cursor."
(interactive)
(save-excursion
(goto-char (point-min))
(insert "TODO: review this file\n")))

Making decisions and repeating things

if takes a condition, what to do when it's true and what to do when it isn't. when and unless are shortcuts for when you only need one side. cond is a chain of options, checked from top to bottom:

(let ((n 7))
(cond ((< n 5) "small")
((< n 10) "medium")
(t "big"))) ; => "medium"

The t at the end works as "otherwise", since t is always true.

dolist walks through a list. This one goes over every open buffer and tells you which files have unsaved changes:

(defun my-list-unsaved ()
"Show which file buffers have unsaved changes."
(interactive)
(dolist (b (buffer-list))
(when (and (buffer-file-name b) (buffer-modified-p b))
(message "Unsaved: %s" (buffer-name b)))))

The messages pile up in the *Messages* buffer, which you can open with C-h e.

A real command: quick notes

Time to put it all together. This command asks for a title, turns it into a clean file name and opens a new Org note in your notes folder, already with a title and the date.

(defvar my-notes-directory "~/notes"
"Where `my-new-note' keeps its files.")

(defun my-slugify (title)
"Turn TITLE into a lowercase, dash-separated slug."
(let* ((s (downcase title))
(s (replace-regexp-in-string "[^a-z0-9]+" "-" s)))
(string-trim s "-" "-")))

(defun my-new-note (title)
"Create a new Org note called TITLE in `my-notes-directory'."
(interactive "sNote title: ")
(let* ((date (format-time-string "%Y-%m-%d"))
(file (expand-file-name
(concat date "-" (my-slugify title) ".org")
my-notes-directory)))
(make-directory my-notes-directory t)
(find-file file)
(when (= (buffer-size) 0)
(insert "#+title: " title "\n"
"#+date: " date "\n\n"))))

(keymap-global-set "C-c n" #'my-new-note)

Press C-c n, type "Ideas for the weekend", and you're editing 2026-11-06-ideas-for-the-weekend.org, with the title and the date at the top. If the file already exists, it just opens, without writing the header twice.

A few new pieces showed up here:

• defvar creates a variable with a description, the polite way to define a setting.
• let* is like let, except each variable can use the ones before it. Here s gets rewritten in two steps.
• replace-regexp-in-string swaps every run of characters that aren't letters or numbers for a dash.
• string-trim removes leftover dashes from the edges.
• make-directory with t creates the folder, and doesn't complain if it already exists.

Read it slowly, change something, run it again. That loop is how you learn Elisp.

Hooks: run code when something happens

A hook is a list of functions that Emacs runs at a specific moment. Every mode has one, named after the mode with -hook at the end. This is how you say "every time I open a text file, do this":

(add-hook 'text-mode-hook #'visual-line-mode)
(add-hook 'prog-mode-hook #'display-line-numbers-mode)

The first line wraps long lines nicely in text files. The second turns on line numbers in any programming mode, since all of them build on prog-mode.

When you need more than one function call, use a lambda, which is a function without a name:

(add-hook 'prog-mode-hook
(lambda ()
(setq-local fill-column 100)
(electric-pair-local-mode 1)))

setq-local changes the variable only in that buffer, so your Python files can have one width and your notes another.

There are hooks for almost everything: before-save-hook, after-save-hook, kill-emacs-hook, emacs-startup-hook. C-h v and the word "hook" will show you the list.

Advice: changing a command you didn't write

Sometimes you want a built-in command to do one extra thing. Advice lets you attach your own function before, after or around it:

(defun my-announce-save (&rest _)
"Tell me which buffer was just saved."
(message "Saved %s" (buffer-name)))

(advice-add 'save-buffer :after #'my-announce-save)

Now every save shows a little message. To undo it, advice-remove with the same arguments.

Advice is powerful, and that's exactly why it deserves care. Reach for a hook first. If there isn't one, then advice is fine, but keep each piece small and give it a clear name, because advice is invisible when you're reading the original command's code.

Reading Emacs's own code

This is where the investment pays off. C-h f describes any function, and the description has a link to the file where it's defined. Click it and you're reading the real source. C-h k does the same for a key: press C-h k and then C-x C-s, follow the link, and you'll see how Emacs saves a file.

Three other help commands that pair well with Elisp:

• C-h o: describe any symbol, function or variable, whatever it is.
• C-h v: describe a variable and show its current value.
• C-h i: the manuals, including the Elisp reference, inside Emacs.

You won't understand everything you read at first. That's fine. Skim, look for the parts you recognize, and every week you'll recognize more.

When things break

Errors in Elisp are normal, and Emacs has good tools for them.

M-x toggle-debug-on-error makes Emacs open a backtrace whenever an error happens. It looks dense, but the top lines usually point straight at the function that failed.

For your own functions, there's Edebug. Put the cursor inside a defun and press C-u C-M-x. The next time the function runs, Emacs stops at the first step and lets you walk through it with SPC, one expression at a time, showing each value as it goes. q gets you out.

If your init.el breaks so badly that Emacs starts in a strange state, remember emacs -Q, which starts without any config. Open the file, fix it, restart. And emacs --debug-init starts with your config and opens the backtrace at the first error, which usually tells you the exact line.

Finally, M-x checkdoc reviews the descriptions in your file and points out small style problems. It's a good teacher.

Organizing your init.el

Once you have a few functions, keep them tidy. Two simple rules go a long way.

Group things by topic, with a comment on top of each group, and keep your own functions together in one section. Use ;;; for section titles. Emacs even understands them: M-x outline-minor-mode lets you fold the file by those headings.

And let use-package do the bookkeeping for packages and built-in features alike. It's built into Emacs since version 29:

(use-package org
:hook (org-mode . visual-line-mode)
:bind ("C-c a" . org-agenda)
:config
(setq org-log-done 'time))

:hook adds hooks, :bind sets keys and :config runs code after the package loads. It's the same Lisp you learned above, organized into labeled boxes.

Where to go next

Inside Emacs, C-h i opens the manuals. Look for "An Introduction to Programming in Emacs Lisp", written for people who have never programmed. It's long, gentle and full of small exercises. When you want the details, the "Emacs Lisp Reference Manual" sits right next to it. Both are also online at gnu.org/software/emacs/manual.

A good next exercise: pick something you do by hand at least twice a week, and turn it into a command. Inserting a template, opening a set of files, cleaning up a pasted text. Small commands that fit your own habits are where Elisp starts to feel personal.

This is part II of a series. Part I is about living inside Emacs: feeds, gopher, the fediverse, chat and mail. Part III turns Emacs into a full programming setup.

Everything was checked against Obsidian 1.15, the current version as I write this. Where a trick only exists in recent versions, I say which one. Keys are written for Windows and Linux; on a Mac, read Ctrl as Cmd and Alt as Option.

Search like you mean it

1. Search has operators. The search pane (Ctrl+Shift+F) understands much more than words. A few that change how you use it:

file:recipe (notes with "recipe" in the file name)
path:"Projects/2026" (notes inside that folder)
tag:#todo (the tag, ignoring code blocks)
line:(server backup) (both words on the same line)
section:(server backup) (both words under the same heading)
task-todo:call (unfinished tasks that mention "call")
task-done:call (finished ones)
match-case:HappyCat (case-sensitive search)

You can combine them. A space means AND, OR means or, a minus sign excludes (-draft), quotes search an exact phrase and parentheses group things. And if a query gets too clever to read, turn on the "Explain search term" toggle in the search pane and Obsidian describes it in plain words.

2. Search by property. Square brackets search your properties. [status:Draft] finds notes with that status, [status:Draft OR Published] finds either, [duration:<5] compares numbers, and [aliases] alone finds any note that has the property at all.

3. Regular expressions work too. Put the pattern between slashes. path:/\d{4}-\d{2}-\d{2}/ finds every file with a date in its path.

4. Put a live search inside a note. A code block with query as its language runs a search and shows the results right there, always up to date:

tag:#read -tag:#done

It's a reading list that maintains itself. One caveat: Obsidian Publish doesn't render these.

Links and embeds you can aim

5. Link to a heading, not just a note. [[Server notes#Backups]] jumps straight to that section. [[#Backups]] does the same inside the current note.

6. Link to a single paragraph. Put a space and an ID at the end of a paragraph, like ^why-restic, then link to it with [[Server notes#^why-restic]]. You don't even have to write the ID yourself: type [[Server notes#^ and Obsidian lists the paragraphs to pick from, and creates the ID for you.

7. Search the whole vault from inside a link. Type [[## and you're searching every heading in every note. Type [[^^ and you're searching every paragraph. It's the fastest way to link to a thought when you don't remember which note it lives in.

8. Embed only the part you need. Add ! before any of those links and the content shows up inline. ![[Server notes#Backups]] shows just that section, ![[Server notes#^why-restic]] shows just that paragraph. Edit the original and every embed follows.

9. Size your images. ![[photo.jpg|300]] makes an image 300 pixels wide and keeps its proportions. ![[photo.jpg|640x480]] sets both sides. Inside a table, the pipe needs a backslash before it, or the table breaks.

10. Open a PDF on the right page. ![[manual.pdf#page=12]] embeds the PDF already on page 12. Add a height with #page=12&height=400.

11. Change what a link says. [[Artificial intelligence|AI]] links to the note but shows "AI" in the text.

Properties that do more than you think

12. Add a property from the keyboard. Ctrl+; adds a new property to the current note. Typing --- on the first line of a note starts the properties block too.

13. Give a note several names. The aliases property lists other names for a note. They show up in link suggestions with a little curved arrow, and picking one writes the link with the alias as display text. The Backlinks pane also catches unlinked mentions of the aliases, so a note called "Artificial intelligence" with the alias "AI" finds every loose "AI" in your vault.

14. Style a single note. The cssclasses property adds a CSS class to one note. Pair it with a CSS snippet and that note can look different from the rest. The example from the official docs puts a red border around the images of one note. In the note:

---
cssclasses:
- red-border
---

And in a file inside .obsidian/snippets:

.red-border img { border-color: #ff0000; border-style: solid; }

Then go to Settings, Appearance, CSS snippets, press the reload button and turn the snippet on.

Writing tricks

15. Callouts that fold. A callout is a quote with a type: > [!tip], > [!warning], > [!question] and a dozen more. Write a title after the type to replace the default one. Add - right after the type and it starts folded, + and it starts open:

> [!faq]- Why is the backup so slow?
> Because it's checking every file the first time.

That's a FAQ that opens on click, in plain Markdown. Callouts also nest, with > > [!todo] inside another one, and in Live Preview you can right-click the title to switch its type.

16. Write things only you can see. Anything between %% and %% is a comment. It stays in the file but disappears in Reading view. It works inline or across several lines. Just remember to close it, because an open %% hides the rest of the note.

17. Highlights come in colors now. ==text== highlights as always. Since version 1.14, put a colored circle emoji right after the opening == and the highlight takes that color. Type == and Obsidian suggests the colors.

18. Footnotes, two ways. The classic way is [^1] in the text and [^1]: the note anywhere below. The lazy way is inline: ^[the note goes right here]. Inline footnotes only show up in Reading view, not in Live Preview, so check there.

19. Diagrams from text. A code block with mermaid as its language draws flowcharts, sequence diagrams, timelines and more. Since 1.15, diagrams follow your theme's colors and you can zoom and pan inside them.

Keys that save hours

20. Many cursors at once. Alt+click adds another cursor. Shift+Alt+drag, or dragging with the middle mouse button, makes a rectangular selection, which is great for editing a column of text. Escape goes back to one cursor.

21. Small keys worth memorizing.

Ctrl+L: turn a line into a checkbox, and tick it
Ctrl+Shift+V: paste without formatting
Ctrl+Shift+K: delete the current line
Ctrl+C with nothing selected: copy the whole paragraph
Ctrl+E: switch between editing and reading

22. Paste a link over text. Select a word, paste a URL, and Obsidian turns it into a Markdown link with that word as the text.

23. Give a key to anything. Every command in Obsidian can get a hotkey in Settings, Hotkeys. Some useful commands come with no key at all. "Move line up" and "Move line down" are the best examples. Give them Alt+Up and Alt+Down and you'll wonder how you lived without them. "Fold more" and "Fold less" are good candidates too.

24. Move whole sections around. Open the Outline pane and drag a heading to another position. The whole section, text and subheadings, moves with it.

Getting around

25. The quick switcher knows more than one trick. Ctrl+O opens it. Enter on a name that doesn't exist creates the note. Shift+Enter creates a note with exactly what you typed, even if other notes match. Ctrl+Enter opens the result in a new tab. And with the box empty, Down and then Enter takes you back to the note you were on before.

26. Pin your favorite commands. The command palette (Ctrl+P) is fuzzy, so "scf" finds "Save current file". In Settings, Command palette, you can pin commands so they always sit at the top.

27. Open links where you want them. Ctrl+click opens a link in a new tab. Ctrl+Alt+click opens it in a split. Ctrl+Alt+Shift+click opens it in a new window.

28. Tabs have tricks too. Ctrl+1 to Ctrl+8 jump to the first eight tabs, Ctrl+9 to the last. Ctrl+Shift+T reopens the tab you just closed. Right-click a tab to pin it. And in the tab group menu, "Stack notes" turns your tabs into sliding panels, nice for reading several notes side by side.

29. Save your layouts. The Workspaces core plugin saves which notes are open, how they're split and how the sidebars look. Make one for writing, one for research, one for the weekly review, and switch between them in a second.

30. Bookmark more than notes. The Bookmarks core plugin saves searches, headings and single paragraphs, not just files. A saved search that you open every Monday is a tiny dashboard.

31. Peek without opening. With Page preview on, hold Ctrl and hover a link in the editor to see the note in a popup.

Core plugins people forget

32. Split and merge notes. Note composer has two moves. Select text and run "Extract current selection" to send it to a new note, leaving a link behind. Or merge a whole note into another one when you realize they're about the same thing.

33. Turn mentions into links. At the bottom of the Backlinks pane, "Unlinked mentions" lists every place that mentions the note by name without linking it. One click links each one. You can also show backlinks right at the end of the note with the "Toggle backlinks in document" command.

34. Meet an old note. Random note opens any note from your vault. It's an easy way to rediscover things you forgot you wrote.

35. Talk instead of type. Audio recorder records from your microphone and embeds the recording at the end of the current note. Good for ideas on the go.

36. Slash commands. Turn on the Slash commands core plugin and type / at the start of a line to run any command without leaving the keyboard.

37. Templates know dates. Inside a template, {{title}}, {{date}} and {{time}} fill themselves in, and the date takes any format, like {{date:dddd, D MMMM YYYY}}. The docs give one tip worth repeating: edit your templates in Source mode, because Live Preview can mess with the variables inside properties.

Bases, past the basics

The vault post used Bases for two simple tables. They can do a lot more.

38. Formulas. A Base can have columns calculated from your properties. A few examples from the official docs:

file.mtime > now() - "1 week"
file.mtime.relative()
if(price, price.toFixed(2) + " dollars")

The first is true for notes changed in the last week, the second shows something like "3 days ago" and the third formats a price only when the note has one.

39. Summaries and groups. Right-click a column and pick "Summarize" to get a sum, an average, the earliest date, how many boxes are checked and more. Group the rows by any property, and fold the groups you don't need.

40. Backlinks as a table. In a Base embedded in a note, this means the note that holds the embed. A filter with file.hasLink(this.file) lists every note that links to the current one, with whatever columns you want. Make that Base once and embed it in your hub notes with ![[Backlinks.base]].

41. More than tables. Bases also show cards, lists and, since version 1.14, a kanban board. And the results menu exports any view to CSV.

Canvas and graph

42. Turn a card into a note. In a Canvas, right-click a text card and choose "Convert to file". The card becomes a real note, with backlinks and everything. Alt+drag duplicates a card, Shift+1 zooms to fit everything and Shift+2 zooms to what you've selected.

43. Paint the graph. In the graph view settings, Groups lets you color nodes by any search. Color path:Projects in one color and tag:#person in another, and the graph starts to show you something. For a smaller picture, "Open local graph" shows only the neighbors of the current note, with a slider for how far to look.

Outside the app

44. Links that open notes. Every note has an address that starts with obsidian://. Run "Copy Obsidian URL for current file" and paste it anywhere: a task manager, a calendar event, an email to yourself. Clicking it opens the note. The same scheme can create notes too, with obsidian://new, and search, with obsidian://search.

45. A command line, since 1.12. On desktop, turn on Settings, General, Command line interface. With Obsidian running, obsidian daily opens today's note from a terminal, and obsidian search query="meeting notes" searches the vault. Scripts and automations can talk to your vault without any plugin.

46. Clip the web. The Obsidian Web Clipper is the official browser extension, free and open source, for Chrome-based browsers, Firefox and Safari. It saves pages as clean Markdown, keeps your highlights and lets you make templates per site, with variables like {{title}}, {{url}} and {{highlights}}.

Safety nets and settings

47. File recovery has your back. This core plugin quietly takes snapshots of your notes, by default every five minutes and kept for seven days. When you delete half a note by accident, go to Settings, File recovery, Snapshots, View, pick the note and restore an older version. The snapshots stay on the device and are not a real backup, so keep a proper one anyway.

48. Hide the noise. Settings, Files and links, Advanced, Excluded files. Anything you list there, like an archive of imports or a folder of attachments, disappears from search, the graph and unlinked mentions, and shows up less in the quick switcher and in link suggestions.

49. Different settings per device. If you sync your vault with something like Syncthing, every device shares the same .obsidian folder, plugins and all. Settings, Files and links, "Override config folder" lets one device use its own, with any name that starts with a dot, like .obsidian-phone. The new folder starts empty, so you set that device up once. After that, your laptop and your phone can have different themes, hotkeys and layouts in the same vault.

50. Make the phone yours. On mobile, Settings, Interface has two settings worth a visit. "Configure mobile toolbar" decides which buttons sit above the keyboard, and any command can be one of them. "Configure mobile Quick Action" sets what happens when you pull down on a note. By default it's the command palette, and it can be anything.

Start with three

Nobody needs fifty tricks at once. Pick three that solve something you already do by hand, use them for a week, then come back for three more. My suggestion for a first round: the search operators, the query block and a hotkey for moving lines.

• hax0r: News for hackers and programmers hax0r.zip

  Daily links from Hacker News, Lobsters, SoylentNews, Tildes and Lemmy communities, what people are discussing next to what just came out.

• so i guess everyone uses llms to think now - eva's site eva.ac

  so i guess everyone uses llms to think now

• If you love a website, back it up blog.mistys-internet.website

  This story starts with a little tragedy. See, I’ve got these old webpages I love to go back and look on every now and then. There’s websites that h...

• We have lift off 🚀: building a gemini server in python willmunn.xyz

  7 years after its invention, I discovered the Gemini protocol. It’s a kind of “back to first principals” alternative to the web, aimed at providing value to independent content creators away from the noise, bots and trackers of the main web.

• Transformei meu Linux no TempleOS : r/linuxbrasil reddit.com
• The Story of Mel catb.org
• A Smaller Internet Can Still Be an Open One widdershins.verja.net

  I read Ben Thompson’s “The End of the Internet”, and I agree with his preference for smaller communities. Where he loses me is the suggestion that the public...

• Could a modern chess engine on a Pentium have defeated Kasparov in 1996? nicholas.carlini.com

  A fun experiment where I back-port all the improvements we've made to chess engines over the last 30 years and run it on a 1996 Pentium Pro to see what we could have done if only we knew more at the time.

• A Second Futamura Projection blog.veitheller.de

  Two months ago, we turned compfuck back into an interpreter and wrote a specializer that, given a Brainfuck program, folded the interpreter away and left…

• On vsyscalls and the vDSO lwn.net

  The 'vsyscall' and 'vDSO' segments are two mechanisms used to accelerate certain system calls i [...]

• *sshole · sshhole.com sshhole.com

  openssh on musl linux has been letting people into password-less accounts since 2016.

• [SECURITY] [DSA 6607-1] apt security update lists.debian.org
• A history of backdoors blog.cryptographyengineering.com

  The past several months have seen an almost eerie re-awakening of the ‘exceptional access’ debate — also known as ‘Crypto Wars’. For those just joining the deba…

• The LISP curse, now coming to your ecosystem! - Tim Zöller javahippie.net

  The LISP curse is often quoted as the reason why so few libraries and reusable components exist for LISP dialects. According to the concept, LISP is so power...

• MCP Explained: how the Model Context Protocol works mcp-explained.com

  Every MCP message on the wire, step by step. Transports, auth, tools, sampling, tasks, tool search and codemode. By Runlayer.

• You should absolutely download your favourite youtube videos criminallyvulgar.dev

  Signal boosting Laura's post that you should absolutely download and archive the stuff that matters to you.

• SourceHut disabled registration bypass blog.arusekk.pl

  You could register accounts on SourceHut instances who disabled registration

• A Look at Datastar - Noteflakes noteflakes.com

  I have always been interested in frontend solutions for building web applications. Even though I'm more of a backend programmer, I really dig all the different techniques people come up with...

• The Cost of Blogging onlinegoddess.net

  It’s easy enough to find a blogging platform that doesn’t cost anything to use, Bear itself has a decent enough free tier, but how many of us do end up spend...

• So my ISP was hijacking my DNS karthihegde.dev

  My ISP was tampering with my DNS queries and handing back bogus IP addresses. Here are the misconceptions about DoH, DoT and DNSSEC that followed, and the setup I actually run.

Remember when getting an email address took a minute? You picked a name, typed a password twice and that was it. No phone number, no "verify it's you", no second email to recover the first one. Cock.li still works like that, and I loved it.

It's a free email host that has been around since 2013 and has more than a million users. The tagline on the front page is "yeah it's mail with cocks", which tells you most of what you need to know about its sense of humor. The rest is on the same page: you will never be asked to verify personal information, because the people behind it believe anyone should have access to email without tying it to the surveillance state.

Signing up takes a minute

The registration page asks for three things: a username, a password and a captcha. That's it. You also choose your domain from a list, and this is where the fun starts. Besides cock.li itself there's airmail.cc, firemail.cc, memeware.net, cocaine.ninja, waifu.club, 420blaze.it, cock.email and several others, some of them a lot ruder. Picking one is half the experience.

Once you're in, new accounts need to unlock sending. Instead of asking for a phone number, cock.li asks your browser to solve a small proof of work, a few minutes of CPU time, and the page that does it is titled, of course, "unblock your cock". It's a clever way to keep spammers out without collecting anything about you.

Email, and a webmail in a single file

You get IMAP and POP at mail.cock.li, so any mail client works: Thunderbird, Claws Mail, Apple Mail, K-9 on Android, Mutt in a terminal.

And then there's Cock-mail, the part that impressed me the most. It's their webmail, written from scratch in 2026, and the whole thing is a single HTML file. You can open it with view-source and read every line of it. That one file runs entirely in your browser and talks directly to the IMAP and SMTP servers over WebSockets. There's no webmail backend in the middle logging in for you and juggling your session. The browser speaks the mail protocols itself, the same way a desktop client would. The developers say it plainly: they believe the best email client is a desktop client, and they built a webmail that behaves like one.

A few things I really like about it:

• HTML emails are turned into plain text, with the links pulled out and listed. Remote images are never loaded. No tracking pixels, no surprises.
• It shows live unread counts and updates by itself when something changes from another client.
• It handles attachments, inline images, emails attached inside other emails, every character set, and opens mailboxes with tens of thousands of messages.
• It works on a phone too, with a portrait layout.
• It's free to use and to deploy on your own mail server, under a permissive license. If your server already speaks WebSockets, that single file is all you need: you set your endpoints at the bottom of it and you're done. The full package, with the server-side helper, is a 60 KB download.

The changelog reads like a craftsman's notebook, with entries like "real IMAP protocol parsing" and support for a mailbox named with a pile of backslashes and quotes, just because it should work. Filters are planned for version 1.0.

More than email

The same account also gives you XMPP, at xmpp.cock.li, so you can chat with any Jabber user in the world with the address you already have.

Everything is also reachable through Tor. There's a .onion address for the website and another one for the webmail, IMAP, POP and XMPP, so you can use the whole service without ever leaving the Tor network.

Small things that show care

The site keeps a plain text log at cock.li/log.txt with every update since 2024, written in a voice that's half status report and half stand-up comedy. It suggests you download it and use diff to see what changed, which is refreshingly honest advice for a changelog. There's a warrant canary, a transparency page and GPG keys for the team, signed by an offline master key.

They own their hardware and say they have no third parties. The privacy policy is written in plain language and says exactly what is kept and for how long, with mail logs cleared after a couple of days.

And it's run by a small team, mostly as volunteer work, kept alive by donations in Monero and Bitcoin. The donation bar on the front page carries a perfect label: "The bar's just here for looks."

Go get an address

If you miss the internet where an email address was something you just had, try it. Pick the domain that makes you laugh, set up a client or open Cock-mail, and if you end up liking it as much as I did, send them a donation. Services like this are rare, and they run on people who care.

Bloggram fixes that. It takes a Telegram channel and turns it into a blog that search engines can read, and it keeps that blog in sync with the channel on its own. You keep writing where you already write.

Three steps, and the third one is automatic

First, you sign in with Telegram. There's no password to create: you send a message to the bot, @bloggygram_bot, and it gives you a button that opens your dashboard.

Then you add that bot to your channel as an administrator, with two permissions switched on: post messages and edit messages. It has to be a channel. Groups don't work.

That's it. The moment the bot becomes an admin, the blog exists. Its address comes from the channel's name, so a channel called "Café Notes" becomes cafe-notes.bloggram.lol. If the channel is public, its older posts come along too, so the blog doesn't start empty. A private channel starts from its next post.

What a post becomes

Every post gets its own page, with an address like /p/123-your-title. The first line of the post becomes its title, so short first lines make good titles. The start of the text becomes the description that shows up under the link in search results and in previews when someone shares it.

The formatting you use in Telegram comes along: bold, italic, underline, strikethrough, code, quotes and links. Even spoilers work, staying hidden until the reader hovers over them.

Hashtags turn into tag pages. Write #travel in a few posts and /tag/travel lists all of them, newest first.

Photos are copied to Bloggram and stored in up to three sizes, so a phone downloads a small file and a big screen gets a sharp one. Albums become a single post with every photo in the order you sent them, and the first photo is the image people see when the link is shared. Video, audio and files stay on Telegram. The post still goes up, with a short note saying there's media to see in the channel.

When you change your mind

Edit a post in Telegram and the page changes within seconds.

Deleting is the funny part. Telegram never tells a bot when a channel post is deleted, so Bloggram has to go and check. It looks at recent posts every few minutes and at older ones less often, and when a post is gone from the channel, its page and its photos come off the blog. For private channels it checks with an empty edit, which is why the bot needs the edit permission.

If you want a post to stay in the channel but not on the blog, you can hide it from the dashboard. The dashboard also lets you change the blog's title, description, language and address, import the history again or delete the blog.

Built to be found

The whole point is search, so every blog gets the boring, important things done right: a proper title and description on every page, canonical addresses, link previews for social networks, structured data that marks each post as a blog post with its date and language, a sitemap, a robots.txt that points to it, and an RSS feed at /rss.xml with the last 50 posts in full.

There's also a rule against spam. Anyone can open a Telegram channel in a minute, and a free blog service is a gift to spammers. So a new blog stays out of search engines until it looks like a real one: at least 5 posts, 10 subscribers in the channel and 3 days of life. Until then, people can read it and follow its feed normally, and only search engines are asked to wait. Bloggram reviews new blogs once a day, and the dashboard shows what's still missing. Links to other sites are marked nofollow, so nobody gets anything out of spamming them.

Small on purpose

Bloggram is one program and one database file. There's no separate database server, no queue service and no cache server. Pages are kept in memory and usually come out in a couple of milliseconds, and the blogs themselves run without a single line of JavaScript. The whole thing runs on a single server.

For you, that means pages that load fast, even on a bad phone connection. It's free, with no ads and no trackers, and the only account you need is the Telegram one you already have.

There are a few limits, mostly to keep things healthy: three blogs per account, photos up to 20 MB and a cap on how many new blogs can open each day. Your own domain isn't there yet, but it's planned. And if you ever want out, you can delete a blog from the dashboard, or delete your whole account by sending /deleteaccount to the bot.

Try it

Bloggram is brand new, still at version 0.01, and it's the kind of thing that gets better with real channels using it. If you run a Telegram channel, or know someone who does, start a blog and see your posts become pages. The documentation explains every detail, from how titles are chosen to what happens to your photos.

And if something breaks or feels wrong, write to me at pablomurad@pm.me.

You don't have to move your whole life into it. The fun is picking one thing, trying it for a week and seeing if it sticks. Each section below works on its own.

Getting packages

Some of what follows is built into Emacs, and some comes as packages. Emacs already knows two package archives out of the box, GNU ELPA and NonGNU ELPA. The config from the first guide also adds MELPA, the biggest community archive. With those three, every package in this post is one use-package block away.

Feeds with elfeed

If you follow blogs, news sites, YouTube channels or forums through RSS, elfeed turns Emacs into a fast, keyboard-driven feed reader. It's on NonGNU ELPA, so Emacs can install it without any extra setup.

(use-package elfeed
:ensure t
:bind ("C-c w" . elfeed)
:custom
(elfeed-feeds
'(("https://planet.emacslife.com/atom.xml" emacs)
("https://example.com/feed.xml" blogs friends)
("https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID" video))))

Each feed is a list: the address first, then any tags you want to give it. Tags are how you'll slice your reading later. If you already have your subscriptions in another reader, export them as OPML and bring them in with M-x elfeed-load-opml.

Press C-c w to open elfeed, then G to fetch every feed. The main screen is a list of entries, newest first:

RET: read the entry
b: open the entry in your web browser
n / p: next / previous entry
r: mark as read
u: mark as unread
+ / -: add or remove a tag
s: filter the list as you type
c: clear the filter
G: fetch new entries
q: quit

Inside an entry, n and p jump to the next and previous one, b opens it in the browser and q goes back to the list.

The filter is the clever part. The default shows unread entries from the last six months, and you can write your own with a small language:

+unread: only unread entries
+emacs: only entries tagged emacs
-video: hide entries tagged video
@2-weeks-ago: only entries from the last two weeks
=example.com: only entries from feeds that match this text

Mix them as you like. @1-week-ago +unread -video shows what you haven't read this week, minus the videos. Press s, type the filter, and the list updates while you type.

Emacs also ships a feed reader of its own, Newsticker (M-x newsticker-treeview), if you'd rather not install anything. Elfeed is faster and nicer to filter, but it's good to know the built-in one is there.

Gopher and Gemini with Elpher

Gopher is the protocol that almost became the web, back in the early 90s. Gemini is its modern cousin, a small protocol made for plain text pages without tracking or scripts. Both are alive and full of personal sites, and Elpher, from NonGNU ELPA, browses both.

(use-package elpher
:ensure t)

M-x elpher opens a start page with your bookmarks. To visit somewhere, press g and type an address:

gopher://sdf.org
gemini://geminiprotocol.net

From there, it's a keyboard browser:

TAB: jump to the next link
RET: follow the link under the cursor
u: go back
g: go to an address
a: bookmark the link under the cursor
A: bookmark the page you're on
B: show your bookmarks
d: download the link under the cursor
.: view the raw source of the page
R: reload

If you read the SDF guide, this is the comfortable way to read the gopherholes of SDF members without leaving your editor.

The fediverse with mastodon.el

mastodon.el, from NonGNU ELPA, is a full client for Mastodon. It also works with other servers that speak the same API, like GoToSocial, Pleroma and Akkoma. Tell it your server and your username:

(use-package mastodon
:ensure t
:custom
(mastodon-instance-url "https://your.server")
(mastodon-active-user "yourname"))

Run M-x mastodon. The first time, it opens your browser so you can authorize the app on your server, then asks you to paste back the code the server shows you. It keeps the login in your auth-source file (usually ~/.authinfo.gpg), so you only do this once. After that, you land on your home timeline.

The keys are short and easy to remember:

H: home timeline
L: local timeline
F: federated timeline
N: notifications
n / p: next / previous post
t: write a new post
r: reply
b: boost
f: favourite
k: bookmark
T: open the whole thread
o: open the post in the browser
s: search
O: your profile
g: refresh
Q: close mastodon.el

Writing a post opens a small buffer. Type, then C-c C-c sends it. Since it's an Emacs buffer, everything you know works there, including the spell checker (M-x flyspell-mode).

Chat: IRC and Matrix

ERC is an IRC client that has been part of Emacs for a long time. Run M-x erc-tls, answer the questions about server, port and nickname, and you're connected. Inside, it's IRC as usual: /join #channel, /msg someone hello, /part to leave.

To join the same rooms every time, list them per server:

(setq erc-autojoin-channels-alist
'(("libera.chat" "#emacs")))

Libera.Chat, where a lot of free software projects live, has an #emacs channel full of patient people. Many public Unix systems and pubnixes also run their own IRC servers, and ERC talks to all of them. If your server asks for a SASL login, ERC has a sasl module: add it to erc-modules and use your NickServ password.

For Matrix, there's Ement.el, from GNU ELPA. M-x ement-connect asks for your Matrix ID and password, and then lists your rooms.

The web with EWW

EWW is a web browser built into Emacs. It doesn't run JavaScript and it shows pages as text with images, which sounds limiting until you realize how many pages read better that way. Documentation, blogs, Wikipedia and most of the small web look great in it.

M-x eww asks for an address or a search term. Then:

l / r: back / forward
g: reload
R: readable mode, which strips everything but the main text
&: open this page in your normal browser
w: copy the address
b: bookmark this page
B: list bookmarks
d: download the link under the cursor
v: view the page source
G: go somewhere else

R is the one that makes EWW worth it. It throws away menus, sidebars and banners and leaves only the article. And & is the escape hatch: when a page really needs a full browser, one key sends it there.

Mail

Email is the deepest rabbit hole here, so this section is a map more than a manual. There are three common paths.

Gnus comes with Emacs. It started as a newsreader for Usenet and grew into a mail client. It's powerful and has its own way of thinking, which some people love and others don't.

mu4e and notmuch both work with mail stored on your disk. A separate program, usually mbsync from the isync project, downloads your mail from the server into a local folder. Then mu or notmuch indexes it, and Emacs gives you fast search, threads and tags on top. Both are installed with your system's package manager, and their manuals explain the setup step by step.

Sending mail, on the other hand, is simple and built in. Tell Emacs who you are and which server to use:

(setq user-full-name "Your Name"
user-mail-address "you@example.com"
send-mail-function 'smtpmail-send-it
smtpmail-smtp-server "smtp.example.com"
smtpmail-smtp-service 587
smtpmail-stream-type 'starttls)

Put your password in a file called ~/.authinfo.gpg, one line per server:

machine smtp.example.com login you@example.com password your-password port 587

The .gpg at the end makes Emacs encrypt the file with GnuPG when you save it, and decrypt it when it needs the password. Your password never sits in plain text in your config.

Now C-x m opens a new message. Fill in the To and Subject lines, write, and C-c C-c sends it.

Small things worth knowing

A few more built-in tools that make Emacs feel like a small desktop:

• M-x calendar shows a calendar. Move with the arrows, . jumps to today, and M-x diary keeps simple appointments in a text file.
• M-x dictionary looks up words in online dictionaries.
• M-x proced lists running processes, like top, and lets you kill them with a key.
• M-x webjump opens favorite sites by short names.
• M-x eshell is a shell that works the same on Linux and Windows.
• M-x doctor is a psychotherapist from the 1960s. It won't help, but it will listen.

If you're on Emacs 31

Two changes in Emacs 31 make this way of living a bit nicer. In a terminal, the mouse now works by default in compatible terminals, so emacs -nw over SSH lets you click links in elfeed or scroll a timeline. And there's a new theme called newcomers-presets, off by default, that turns on a set of friendlier settings for people new to Emacs. Enable it like any other theme, with M-x load-theme.

A starter block

Here are the packages from this post together, to paste after the config from the first guide:

;;; Living inside Emacs

(use-package elfeed
:ensure t
:bind ("C-c w" . elfeed)
:custom
(elfeed-feeds
'(("https://planet.emacslife.com/atom.xml" emacs))))

(use-package elpher
:ensure t)

(use-package mastodon
:ensure t
:custom
(mastodon-instance-url "https://your.server")
(mastodon-active-user "yourname"))

(use-package ement
:ensure t)

(setq erc-autojoin-channels-alist
'(("libera.chat" "#emacs")))

Select it and press TAB to let Emacs indent it nicely. Then M-x eval-buffer, or just restart, and every tool in this post is a command away.

So I keep making them. This post is a walk through eight small things I built and love: five cozy places from the same house, and three ravens that carry email around. All of them are free. Like I wrote on theraven.my: "All my projects are free to use. And when they mature, they become free and open-source software."

Five rooms in the same house

The first five share a house called muradcorp. Each one has a single job and the same rule: no ads, no tracking, nothing you didn't ask for.

bimb.ooo, somewhere to put things

bimb.ooo is a small home for text, guarded by a pink elephant. You can paste a snippet of code, write a page in Markdown or hand-roll a tiny site with an index, a style.css and an about. Everything lands at you.bimb.ooo, under a name you pick, at paths you can read out loud over the phone.

There's no build step and no folder to upload. Every site gets an Atom feed at /feed.xml on its own, so people can follow you from a feed reader without you doing anything. Under the hood it's one Go binary with SQLite behind it, and every person lives on their own subdomain, so one person's HTML can never touch someone else's.

It's invite only, in the nicest way: you ask for a seat, and you can see who is already here before you do.

tuno.place, a board for loose notes

tuno.place is a board of colorful note cards, with Tuno, a white cat holding a pencil, at the top. You write a note, then make it look like yours: rounded rectangle, square, circle, arch, pill or hexagon, a background you can shuffle, a string tied from one note to another. When a note is done, you can save it as a picture or print it.

The notes never leave your browser. There's no account and no server holding them, which also means backing them up is your job (there's a button for that). It's officially described as "delightfully buggy".

pupu.page, a quiet place to write

pupu.page is a room for writing one thing at a time. The first thing it asks is "how is the light where you are?", night or day, and then it gets out of the way. Pupu, a small black cat, sleeps through both.

You write in Markdown, and the punctuation steps aside: the stars and pound signs hide on every line except the one you're on, so what you see already reads like finished writing. The line you're typing holds still while the page moves around it, and everything except the sentence you're in can fade out, so your eyes have nowhere else to go. When you're done, you export a .md file that's byte for byte what was on the screen.

It works offline, saves as you type, and makes no request to anywhere else. Even the fonts live on the site itself, so nobody learns that you sat down to write today. No account, no server, no AI.

tedy.science, a desk for everyday sums

Tedy's Science is a notepad that does math. You type lines the way you'd say them, and the margin answers. Ted, a ginger cat with his tongue out, supervises.

Write lunch 45 + uber 22 and the margin says 67. The words are just labels, so your sums stay readable. A few more things it understands:

850 + 20%: 1020
15% of ? = 60: ? = 400
120 km / 2 hours: 60 km/h
today + 30 days: the date 30 days from now
1200 in 12x: twelve payments of 100
1/3 cup * 3: 1 cup

The ? is the neat part: put it anywhere in a line and Ted solves for it. There are variables, headings that split a sheet into sections with their own subtotals, units that refuse to add kilograms to hours, dates, fractions, a scientific calculator running the same engine, and a set of ready-made formulas to paste in.

Your sheets live in your browser. To share one, you send a link, and the whole sheet travels inside the part of the address after the #, which never reaches the server. And if Ted is earning his keep, you can buy him a treat on Ko-fi.

phlog.space, a photo log of wrecked photos

phlog.space is a photo log where your pictures get wrecked on purpose. You post a JPEG or PNG, and on the way in it gets one of 36 effects, picked at random: crunchy JPEG, pixel sorting, VHS, CGA and VGA palettes, fax, thermal camera, Kodachrome, Super 8, silent film, cyanotype, a square 2012 phone-app filter and more. Then it's shrunk to 400 pixels or less, and the original isn't kept.

If you'd rather post a photo as it is, you can turn the effects off in your settings. The rest is built like the old web: each member can leave one "nice" and one single-line comment per photo, sign other members' guestbooks and browse by month. Profiles live at /~name and come with a hit counter, and there's a random photo link, a member list, an RSS feed and an 88x31 button for your own site.

Under the hood it's plain PHP with SQLite, no framework and no JavaScript. New accounts wait for an admin to let them in, so register and give it a little time.

Three ravens

The other three are about the one protocol that everybody already has: email. No app to install, no new password, no feed. You write from the mail program you already use.

theraven.email, contact forms delivered by raven

RavenMail gives you free contact forms for any website. Make a form, put it on your site, and every message lands in your inbox, with Reply-To set to the sender so you answer by pressing reply.

Each form works three ways at once: as a link you can put in a bio, as an embed with one script tag, or as the target of a plain HTML form with no JavaScript at all. You sign in with a link sent to your email, so there's no password to forget.

What you get, all of it free: up to 10 forms, custom fields, attachments, webhooks to JSON, Discord or Slack, your own colors for light and dark mode, and labels in English, Portuguese or Spanish. Spam gets stopped without sending your visitors to anyone else: a small proof of work solved in their browser, a hidden trap field and a few limits. There's no upgrade screen. It's funded by donations.

theraven.my, a town of letters

theraven.my is a blog you write by email. Each resident has a house and a secret address. You send an email to that address, and it becomes a post. Attach photos, and they become the pictures. You can sign up, edit, delete and change your settings, all by email. The site is only for reading.

Everybody's posts meet in the town square, and there's a button to knock on a random door. It's a nice place to send a poem, a photo from your walk or a "we arrived" to your family. The last thing I posted there was Poe's The Raven. To move in, email hello@theraven.email.

theraven.social, good company delivered

theraven.social is the newest raven. It's a small post office for people who write letters.

You follow a few people, and their new letters arrive together in a single email, daily, twice a week or weekly, at the hour you pick, in your time zone. Each delivery has an end. Every letter has its own reply address, so when you write back, only the author reads it, and your email address stays hidden. Nobody sees who follows whom.

Just as important is what it doesn't have: no endless feed, no likes or rankings, no public follower counts, no read receipts or tracking pixels, no ads, no recommendations tuned to keep you scrolling, no AI writing or summarizing letters, and no app to install. You can do all of it from your mail program. Independent servers can even federate with each other.

It's open by invitation, and the archive of public letters is still empty. The first one could be yours.

Why small

None of these is trying to be big. Each one does one thing, keeps your words and pictures where you put them and lets you leave whenever you want.

Try one, or all eight. And if you make something with them, write to me. A raven will find me.

You don't need to be a programmer for most of it. You don't need old hardware either. A browser and a bit of curiosity get you surprisingly far.

A small dictionary first

The scene has its own slang, and the sites you're about to visit use it everywhere. These are the words worth knowing before you start:

• prod: short for production. Any release counts: a demo, an intro, a music track, a picture.
• demo: a real-time audiovisual piece with no size limit, or a generous one.
• intro: a demo with a strict size limit. The common ones are 64k (65,536 bytes) and 4k (4,096 bytes), and there are smaller categories like 1k, 256b and even less.
• party: a demoparty, the event where people meet and release prods.
• compo: a competition at a party, split by category. PC demo, Amiga demo, 4k intro, tracked music, pixel graphics and so on.
• wild: the compo for anything that doesn't fit the others. Videos, hardware hacks, odd machines.
• oldschool and newschool: roughly, old machines (C64, Amiga, Atari, Spectrum) versus modern PCs. Each party draws the line in its own way.
• capture: a video recording of a prod, made because running the real thing isn't always easy.
• handle: the nickname a scener uses. Almost nobody signs with their legal name.
• greetings: the shout-outs to other groups, usually somewhere inside the prod itself.
• party version and final version: prods are often finished at the last minute, so a fixed version sometimes comes out weeks later.
• remote entry: a prod sent to a party by someone who isn't there in person.

Step 1: watch a capture

The easiest way in is a video. Almost every well-known prod has a capture on YouTube, and the database sites below link straight to it. Use full screen, turn the sound up and give it the whole running time. Demos are built like music videos, and a lot of them only make sense once the soundtrack kicks in.

If you want to see the scene live, Revision, the biggest pure demoparty around, streams the whole thing on Twitch at twitch.tv/revisionparty, with a main stage and a separate stream for the seminars. Its YouTube channel is @RevisionParty. Watching the compos live, with the chat reacting to every effect, is a pretty good way to understand the culture in one evening.

A capture is a recording, though. It's the photo of the cake, and later in this guide you'll get to eat the cake.

Step 2: find the good stuff

There are about 2,000 prods released every year. You need a map.

Pouët

Pouët is where sceners rate and comment on prods. Every prod gets a page with the group, the platform, the party and the place it got in the compo, plus links to the download, the capture and often the source code or a making-of.

The votes come in three flavors: a thumbs up, a thumbs down and a little pig face in the middle, which the site's own FAQ describes as "meh". The front page has an all-time top list and a top of the month list. For a beginner, those two boxes make a very good first playlist.

A tip about the comments: read them, but don't take them too seriously. Some are deep technical analysis, and some are one-word insults that have been sitting there for decades.

Demozoo

Demozoo is the encyclopedia. Where Pouët is opinion, Demozoo is record: who made what, in which group, at which party, with which credits. You can browse by platform (it lists more than a hundred), by party and by person, and every party page has its full results.

Look at the downloads box on a page like this one: party version, fixes, wrappers for modern systems and a video capture, all in one place. For some ZX Spectrum prods, Demozoo can even run the original right in your browser.

Awards and yearly picks

The Meteoriks are the scene's yearly awards, handed out on stage at Revision since 2015. A jury picks the winners in most categories, and there's always a Public Choice and a New Talent award. The list of nominees for a year is a great shortcut to what mattered in that year.

Another good shortcut is a yearly write-up like The best demos of 2025 from the demoscene, which picks a handful of prods, embeds the videos and links to Pouët.

Step 3: run the real thing

This is where it gets fun. Running a demo means your own computer is drawing every frame and playing every note right now. For an intro, it also means a file of a few kilobytes is doing all of that.

Modern Windows prods

Most new PC prods are Windows executables. Download them from the link on Pouët or Demozoo, which usually points to scene.org, unzip and run.

Your antivirus may complain. Size-limited intros squeeze their code with executable packers, and some security tools see packed code as suspicious. The Pouët FAQ says it plainly: files hosted on scene.org can be considered clean. If you're still unsure, read the comments on the prod page. Sceners are quick to shout when something is actually wrong.

Also read the .nfo file that comes in the zip. It's a small text file with credits, greetings and, often, the hardware the prod needs. A 4k intro that renders everything with shaders can ask a lot from your graphics card, and the .nfo will tell you before your fan does.

DOS

For the classics of the 90s, like Second Reality, you need a DOS emulator. The two most active ones are DOSBox Staging and DOSBox-X, both free and available for Windows, macOS and Linux.

Old demos can be picky. If one crashes, three things usually help: put it in a short folder path (something like C:\REAL), set a fixed number of CPU cycles instead of the automatic setting, and try another sound card option if the music is the problem.

A nice detail: Future Crew released the source code of Second Reality in 2013, for the demo's twentieth anniversary. It's on GitHub, and reading it is a lesson in how people wrote software when every byte mattered.

Amiga

For the Amiga, use WinUAE on Windows, or FS-UAE and Amiberry on other systems. The catch is the Kickstart, the Amiga's ROM. The original ROMs are sold legally in Amiga Forever, which also bundles a selection of demoscene prods. There's a free replacement called AROS, and WinUAE has it built in, but it runs some software and not all of it, so expect a few demos to fail.

Commodore 64

For the C64, use VICE. The official builds come with the C64 ROMs included, so it works out of the box. On some Linux distributions the packaged version has the ROMs removed, so the official build is the easier path.

Atari ST and Falcon

Hatari emulates the ST, STE, TT and Falcon. Its official builds ship with EmuTOS, a free replacement for the Atari's operating system, so you can start without hunting for the original TOS.

ZX Spectrum

Fuse runs on Linux, Windows and macOS. And remember that Demozoo can run some Spectrum prods straight in the browser.

A watchlist for after the classics

The first post already pointed at Second Reality, State of the Art, Desert Dream, fr-08 and Elevated. These are good next steps, grouped by type. Each link goes to the Pouët page, where you'll find the capture and the download.

Demos for PC:

• fr-041: debris. by Farbrausch, 1st at Breakpoint 2007. A city falling apart, from a download that's famously tiny for what it shows.
• Agenda Circling Forth by Fairlight and CNCD, 1st at Breakpoint 2010.
• Razor1911 by Razor 1911, winner of the PC demo compo at Revision 2026. Razor 1911 started on the C64 in Norway in 1985 and became one of the most famous cracking groups in history. Forty years later, the same name wins the biggest pure demoparty around with a demo. If you read the first post, you know why that's funny.

64k intros:

• Heaven Seven by Exceed, 1st at Mekka and Symposium 2000.
• The Timeless by Mercury, 1st at Revision 2014.
• Clean Slate by Conspiracy, 1st at Revision 2021.
• Squidopus Famelica by With Love, the 64k winner at Revision 2026. You'll find it in the Revision 2026 results.

4k intros:

• Atrium by TBC and Loonies, 1st at Breakpoint 2008.
• Cdak by Quite and Orange, 1st at Chaos Constructions 2010.
• duo by Nuance, the 4k winner at Revision 2026, also in the results page above.

Amiga:

• Starstruck by The Black Lotus, 1st at Assembly 2006, for the Amiga AGA and the Atari Falcon.
• Second Nature by Desire and The Twitch Elite, the Amiga demo winner at Revision 2026.

Commodore 64:

• Edge of Disgrace by Booze Design, 1st at X 2008.

A good habit: when a prod hits you, open its Demozoo page, look at the group and watch what else that group made. Do the same with the musician and the graphician in the credits.

Step 4: make something

The scene isn't only coders. Every party has compos for music and graphics, and a lot of prods are made by a group where only one person writes code. Pick the door that fits you.

Shaders, right in the browser

A shader is a small program that runs on the graphics card and decides the color of every pixel on the screen. A big part of modern demos and intros is made of them, and you can start writing one in the next five minutes.

Shadertoy is a website where you write shaders in GLSL and see the result instantly. You can browse and edit any shader on the site, change a number and watch what happens. It's a great way to learn: open something beautiful, break it and figure out why it broke.

When you get comfortable, look at live coding. At Revision there's the Shader Showdown: two coders on stage, 25 minutes, an empty editor, a DJ playing, and they write a shader from scratch while the audience watches. No notes, no phones, no USB sticks. The crowd picks the winner by cheering. The tool they use is called Bonzomatic, it's free, and you can practice with it at home. There's a whole archive of these events, with the code of each round, at livecode.demozoo.org.

Fantasy consoles

A fantasy console is a computer that never existed, with limits chosen on purpose. It's the closest thing to an 80s home computer you can download today.

TIC-80 is free and open source. It has a 240x136 screen, a 16-color palette, 4 sound channels and built-in editors for code, sprites, maps and sound. There's an optional paid Pro build, but the free one does everything you need to start.

TIC-80 has become a real scene platform. There are regular byte jams, live sessions where people code effects on it together, and sizecoding parties have whole compos for it. PICO-8 is the paid cousin (US$14.99), with a 128x128 screen and 16 colors, and a big community of its own.

Sizecoding

Sizecoding is the art of making something impressive in a ridiculously small file, think 256 bytes, or 128, or 64. This line of the post you're reading is already longer than some of those prods.

The best place to see it happen is Lovebyte, an online party dedicated to it, usually in February, held on Discord with the compos streamed on Twitch. It has intro compos from 1k down to 32 bytes, split into oldschool and high-end, plus categories for tiny graphics, tiny music and bytebeat, and a compo just for new talent. Since it's online, anyone can take part from home.

To learn, the sizecoding.org wiki is the reference, with a focus on tiny programs for the x86. If you'd rather start with JavaScript, Dwitter is a site of visual demos written in 140 characters. Every dweet is a little puzzle, and reading other people's is half the fun.

The tools behind 4k and 64k intros

If you get serious about size-limited intros on Windows, these names will show up again and again:

• Crinkler: a compressing linker for 1k, 4k and 8k intros. It's what turns your code into a tiny executable.
• kkrunchy: an executable packer made mainly for 64k intros.
• 4klang: a synthesizer built for 4k intros. You compose the music, and it becomes a few hundred bytes of code.
• Sointu: an evolution of 4klang that runs on Windows, Mac, Linux and even in the browser.
• Oidos: an additive synthesizer for 4k and 8k intros, with a matching reverb.

They're all free.

Music: trackers

A tracker is the classic way to make scene music. Instead of a piano roll, you get columns of notes scrolling down the screen, like a spreadsheet that plays. It looks strange at first, but the logic is simple: each row is a step in time, and each column is a channel playing its own sound. Every party has a tracked music compo.

• OpenMPT: free, for Windows.
• MilkyTracker: free and open source, in the style of FastTracker II, for Windows, macOS and Linux.
• Furnace: free and open source, for chiptune, emulating the sound chips of many old systems.
• pt2-clone: a faithful copy of ProTracker, the classic Amiga tracker.
• Renoise: commercial, with a demo version, and the most modern of the bunch.

Pixel graphics

The graphics compos are mostly pixel art, often with the palette and resolution of a specific old machine.

• GrafX2: free and open source, inspired by Deluxe Paint, the program that defined Amiga graphics.
• Pro Motion NG: has a free edition and a cheap full version.
• Aseprite: paid, very popular, and great for animation.

Step 5: release it

When something is done, release it. The scene is built on releases, and a small finished thing is worth more than a big unfinished one.

You don't have to travel to enter a compo. Since 2023, Revision accepts remote entries. In 2024 there were 85 of them, next to the entries made on site. Other parties have their own rules, so check the rules page of each one before sending anything. Online parties like Lovebyte are an even easier start.

When you release, a few habits help:

• Include an .nfo file with the title, the group, the credits, the party and the greetings.
• Add the prod to Pouët and Demozoo, so it's findable and part of the record.
• Make a capture, because most people will watch the video first.
• Read the feedback, keep the useful parts and let the rest go.

Step 6: go to a party

This is the heart of it. A party is where people finish prods at four in the morning, watch the compos together on a big screen and vote. Most of the big ones are in Europe, and their dates move every year, so always check demoparty.net or Demozoo before planning. To give you an idea of the calendar:

• January: Gerp, in Skövde, Sweden.
• February: Lovebyte, online, and BCC Party in Germany (26 to 28 February 2027).
• Easter: Revision, in Saarbrücken, Germany.
• May: Outline, in Ommen, the Netherlands.
• July: Black Valley, near Oslo, Norway (9 to 11 July 2027).
• Summer: Assembly, in Helsinki, Finland, and the summer edition of Silly Venture, the Atari party, in Gdańsk, Poland.
• August: Evoke, in Cologne, Germany, and Xenium, in Poland.
• October: Deadline, in Berlin (1 to 3 October 2027).
• November: the winter edition of Silly Venture, also in Gdańsk.
• December: Inércia, in Portugal.

Outside Europe, there's Syntax in Australia, Demosplash in the United States and Flashparty in Buenos Aires, the most visible party in Latin America.

Revision publishes a small guide called How to scene for first-timers, and in 2026 it had a seminar for beginners. If you go, read the guide before you leave home. If you can't go, watch the stream: it's the next best thing.

Where to talk to people

The scene still lives in old corners of the internet. The Revision guide lists IRC channels like #newsceners, made for exactly the person reading this, and #revision, plus a Discord server. There's also a general demoscene Discord server, which some parties point newcomers to. Ask questions, show what you made and greet people back when they greet you.

And if you're in Brazil or anywhere in Latin America and you're part of the scene, or want to be, write to me. Our scene has always been small, and that only changes when people find each other.

The short version

If you read nothing else, do this tonight: open the all-time top on Pouët and watch three captures. Pick the one you liked most and run the real thing. Then open Shadertoy and change one number in a shader you like.

That's already more than most people ever do with a computer.

They're pubnixes, short for public Unix systems: machines that a bunch of people share over the internet. You get an account, a home folder, a shell and a web page at an address with a tilde in it, like server/~you. There's no feed, no likes, no algorithm and nothing to scroll. Just files, text, links and whoever else happens to be logged in.

Each of the three runs a different operating system, which means each one is a different kind of fun. One is a friendly Linux box with a long list of goodies, one is a quiet OpenBSD machine, and one runs Plan 9, the operating system Bell Labs made after Unix. Pick one, or knock on all three.

runv.club, the busy one

runv.club is a small public Unix server run from Brazil, on Debian. It's the one with the most toys, and it's a good first pubnix if you've never had a shell account anywhere.

When you join, you get:

• a shell over SSH or mosh, with editors, git and a pile of languages: Python, Perl, C, Go, Rust, Node, Ruby, Lua, Haskell and a few Lisps
• a web page at runv.club/~you, plus a Gemini capsule and a Gopher hole
• a blog that writes itself: drop Markdown files in ~/blog and they show up on the web, Gemini and Gopher at once, and on the planet that gathers everyone's posts
• a spot on the runv ring, our webring
• your own address at you.tun.runv.club, for an app running there or a tunnel from your laptop
• an eepsite with its own address on I2P
• private Git, a bookmark keeper and an RSS reader
• a seat in #runv on tilde.chat, through our IRC bouncer, so you stay in the room even with the laptop closed
• pastes, twtxt, finger, a forum that lives in the terminal, and a dashboard: just type runv

The planet is still empty. Your first post would be the first post on it, which is a nice thing to be able to say.

It's also a great place to learn Linux without breaking your own computer. Every request to join is read by a person, and we let in five people a week, so the place grows slowly. You need to be 16 or older and have an SSH key. Ask at the join page, or straight from a terminal:

ssh join@runv.club

If you want the backstory, I wrote about why we brought runv.club back after the first version closed.

noctem.cafe, the quiet one

noctem.cafe is a shared Unix machine running OpenBSD, hosted in Minas Gerais. It's small on purpose. Where runv is a busy club, noctem.cafe is a café at night with a couple of tables and a good lamp.

It's a place for personal pages, shell use, Gopher spaces, Gemini capsules, I2P pages and small experiments. Every page is reachable on the web, on Gopher, on Gemini and through I2P.

OpenBSD is known for careful engineering, good manual pages and a strong focus on security. If you've always been curious about it, a shell account on someone else's OpenBSD box is the gentlest way in. You can read man pages that actually explain things, poke at ksh, and see how a system feels when everything was designed by the same people.

The house rules fit in three lines: be kind to the machine, no spam, mining, scanning or abuse, and keep your files simple and your neighbors in mind. Right now there are only two users, so there's plenty of room at the counter. There's no signup form yet. If you'd like a home there, send me a message on Mastodon at @pmurad@murad.social and tell me a little about what you'd do with it.

Noctem 9, the strange one

noctem9.cafe doesn't run Linux or BSD. It runs 9front, the living fork of Plan 9 from Bell Labs, the system where everything is a file, the windows are made by rio and the mouse has a lot more to say than on any other desktop.

This is the easiest one to join. Go to the sign up page, pick a name and a password, answer how much 3 plus 2 is, and you have an account. Free, one per person, done in a few seconds.

You don't log in with SSH. You use drawterm, a small program that opens a real Plan 9 screen on your own computer. Download it from drawterm.9front.org and run:

drawterm -h noctem9.cafe -a noctem9.cafe -u yourname

Type your password at the dp9ik password: prompt, right-click the gray screen, pick New, draw a window, and you're in a Plan 9 shell. It works from a phone too: I wrote a guide to running drawterm on Android.

Once inside, anything you put in $home/www shows up at noctem9.cafe/~yourname/. Plain HTML, no build step. And there's a wall that everybody can sign: type mural followed by your message, and it shows up at /mural.txt for the whole world to read.

The machine is honest about its size. One virtual CPU, 1 GB of RAM and about 3.7 GB of disk, shared by everyone, with 60 MB per account. That's plenty for text, a homepage and a lot of curiosity. The only member listed so far is ~glenda, the bunny, and she would like some company.

Why bother

Because it's fun, mostly. You log into a computer that isn't yours, type who and see other people's names, read a page that lives one folder away from yours, and leave a note on a wall that no algorithm moderates.

It's also a good classroom for Unix. You learn by living in it: editing files with a terminal editor, fixing your own page when you break it, reading man pages because you actually need them. Nobody grades you, and the worst thing that can happen is a broken index.html.

And it's a small way to keep the old web alive. Personal pages at tilde addresses, Gopher holes, Gemini capsules, a shared IRC channel. None of it needs you to have an audience. It only needs you to show up.

So pick the machine that sounds like you. runv.club if you want company and a lot to play with, noctem.cafe if you want a quiet corner on OpenBSD, Noctem 9 if you want to try an operating system that thinks differently. Or join all three and tell me which one you like best.

See you on the servers.

pmurad

It's called weirdnet.org, and it's a hand-made map of the small, weird, personal web. Right now it holds 45,589 links, sorted into 314 categories and 899 tags. There's no feed deciding what you see, no ranking, no ads. Just a big pile of human websites and a lot of ways to fall into them.

Yes, it looks like 1996. That's on purpose. Times New Roman, blue and purple links, gray buttons and a green hit counter. The pages are plain HTML with one tiny stylesheet for the whole site, and almost no JavaScript. It loads fast on a bad connection and it'll look the same in ten years.

Where to start

Press Random

It's the easiest way in. The Random button on the home page sends you to one site from the collection, no questions asked. It might be a tiny Neocities page, a forgotten archive or somebody's blog about woodworking. Press it again and you're somewhere else entirely. It's channel surfing for websites.

The Directory

directory.weirdnet.org is the organized side. Sites are filed by category, and the categories go from the obvious to the delightfully specific:

• Personal sites (6,577), the heart of the whole thing
• Archives (4,819), for when you want to dig
• Retro web (910) and Retro computing (302)
• 512kb club (894), sites that weigh less than half a megabyte
• Amateur radio (682), a whole world of call signs and QSL cards
• Zines (507), Net art (599) and Subcultures (568)
• Paranormal (328), because of course

Every site has a short description, so you know a little about where you're going before you click. And there's a list of all 314 categories plus a tag browser, if you want to go down a very specific hole.

The Link Dump

links.weirdnet.org is the messier sibling, with the motto "...i found this and dropped it here." Everything shows up in the order it arrived, newest first, with tags, an archive by month and a search box. On any given page you might find an old GeoCities page next to a 1980 computer animation, a zine scan on the Internet Archive and somebody's essay on Hermetic symbols.

The Link Dump has RSS and Atom feeds, so you can drop it into your feed reader and get a little stream of the weird web every day.

The odd little rooms

Besides the directory, weirdnet has a few corners that have nothing to do with links.

Crazy letters. Over a hundred absurd letters, with titles like "Ghost included in the price", "Buying a flea", "Small talk with a frog-man" and "The great stoat revolution".

Letters of Hart. A small archive of 36 texts by Michael S. Hart, who started Project Gutenberg in 1971 by typing the Declaration of Independence into a university computer and sharing it on the network. The texts are about books, reading and free access to both.

Weird recipes. Forty old recipes, the kind with spelling from another century. Stewed Pompions, Bird's Nest Pudding, Raspberry Shrub, Potatoe Pasty and, yes, Parmesan Ice Cream.

Photos. A handful of random trips from before 2008.

Stats. A page that looks like an old BBS sysop screen, green on black, reporting the numbers of the whole place, including the line "ALGORITHMS: 0 detected".

If you want your own corner

Browsing a few hundred personal sites has a side effect: you start wanting one. The Start your own site page is a friendly guide for exactly that moment. It walks through getting a domain, picking a place to publish (Neocities, Nekoweb, Bear Blog, Mataroa, prose.sh and others), turning on a feed and saying who you are with an h-card. No jargon wall, and you can stop whenever you have enough.

And if you already have a weird, personal, hand-made site, or you know one that belongs in the collection, there's a Suggest a site page. Personal sites, fan shrines, odd archives, webrings and small tools made with love are all good fits.

Why it exists

There's a manifesto on the site, and one line from it sums up the whole project better than I can here: "The centralized web is a mall with velvet ropes. The decentralized web is a city: messy, alive, uneven, full of tiny lights."

weirdnet is my attempt at a map of that city. It's free, it has no account to create and nothing to install, and it's open to anyone with a browser and a free afternoon.

So go on. Open weirdnet.org, press Random, and tell me where you landed.

It started in 2003 as a better way to fold outlines, and it's been part of Emacs since the mid-2000s. In 2026 it's on version 9.8 and still going. The files you write today will still open decades from now, in any text editor, with no app, no account and no export step, because they're just text.

This guide starts at the first star and goes all the way to agendas, code blocks and exporting a PDF. You don't need to read it in one sitting. Each section works on its own, and the cheat sheet at the end is there for the day you forget a key.

Before you start

You need Emacs. If you don't have it yet, my post Emacs for the curious covers installing it on Linux and Windows and surviving the first day. Org already comes inside Emacs, so there's nothing else to install. If you ever want the newest Org, it's on GNU ELPA, the official package archive.

A quick reminder of how Emacs keys are written, because this post is full of them:

C-c: hold Ctrl and press c
M-x: hold Alt and press x (or press Esc, then x)
C-c C-t: Ctrl+c, then Ctrl+t
S-TAB: Shift+Tab
M-RET: Alt+Enter

To start, open a file whose name ends in .org, for example C-x C-f ~/org/inbox.org. Emacs sees the extension and switches to Org mode on its own. Everything below happens in that file.

One star, two stars

A heading is a line that starts with one or more stars and a space. More stars, deeper level:

* Home
** Kitchen
*** Fix the dripping tap
** Garden
* Work
** Blog
*** Write the Org post

Everything under a heading, until the next heading of the same level, belongs to it. That's the whole idea of an outline, and it's what makes the next trick possible.

Folding with Tab

Put the cursor on a heading and press TAB. The heading closes and shows three dots, meaning there's something inside. Press TAB again and you see the children. Once more and everything under it opens. Org calls this cycling: folded, children, everything.

S-TAB does the same for the whole file at once. Press it a few times and the file goes from only top-level headings, to all headings, to every line of text.

This is the first thing that makes Org feel different from a normal text file. A file with three hundred lines can look like five lines, and you open only the part you're working on.

Moving things around

You never need to cut and paste a section in Org. You grab it with the keyboard and move it:

M-RET: new heading at the same level
C-RET: new heading after the whole current section
M-left / M-right: promote or demote this heading
M-S-left / M-S-right: promote or demote it with all its children
M-up / M-down: move the whole section up or down, children included

Try M-down on "Kitchen" in the example above. The heading jumps below "Garden" and takes the dripping tap with it.

Writing inside headings

Under a heading you write normal paragraphs. Org gives you a handful of marks for inline styles:

*bold* /italic/ _underline_ =verbatim= ~code~ +strike-through+

Lists are as simple as they look. Dashes or plus signs for bullets, numbers for ordered lists, and a double colon for term and definition:

- eggs
- flour
1. preheat the oven
2. mix everything
- Org :: an outliner made of plain text

M-RET inside a list adds a new item, and M-up and M-down move items around, the same keys you use for headings. Org also renumbers ordered lists for you when you move things.

Checkboxes

A checkbox is a pair of square brackets with a space inside, placed right after the dash. The fastest way to make one is to let Org write it: put the cursor on a list item and press C-u C-c C-c. Then C-c C-c ticks it, and the empty box becomes [X]. In a list that already has checkboxes, M-S-RET adds a new item with an empty box.

Add a cookie to the heading above the list, [/] or [%], and Org keeps count for you:

* Packing for the weekend [2/2]
- [X] passport
- [X] charger

Every time you tick or untick a box, the cookie updates. Untick the charger and the heading goes back to [1/2]. [%] shows a percentage instead.

TODO: turning notes into tasks

Any heading becomes a task when it starts with a keyword:

* TODO Renew the domain
* DONE Pay the electricity bill

C-c C-t cycles the heading through no keyword, TODO and DONE. S-left and S-right do the same thing in both directions.

Your own keywords

Two states are enough for a shopping list, but real work has more steps. Put a line like this at the top of a file:

#+TODO: TODO NEXT WAIT | DONE CANCELED

Everything before the bar is open, everything after it is finished. Press C-c C-c on that line so Org reloads it, and now C-c C-t walks through all five. The config at the end of this post sets the same keywords for every file.

Remembering when you finished

Add this to your config and Org stamps the moment you close a task:

(setq org-log-done 'time)

* DONE Pay the electricity bill
CLOSED: [2026-11-06 Fri 10:42]

It looks like a small thing until the day someone asks "when did we send that?" and the answer is sitting right under the heading.

Priorities

A priority cookie goes right after the keyword:

* TODO [#A] Back up the server before the update
* TODO [#C] Reorganize the bookmarks

A is the highest and C the lowest. S-up and S-down on a heading change it, and C-c , asks for it directly.

Tags

Tags go at the end of the heading, between colons:

* TODO Call the accountant :work:phone:
* Trip to Ouro Preto :travel:
** TODO Book the hotel

C-c C-q adds or edits tags with completion. Children inherit their parents' tags, so "Book the hotel" counts as :travel: without saying it. That matters later, when you search by tag.

Dates: scheduled, deadline and plain

Org understands dates written between angle brackets:

<2026-11-10 Tue>
<2026-11-10 Tue 14:00>

You don't type them by hand. C-c . opens a little calendar and a prompt, and the prompt is smarter than it looks. You can type a date, but also things like these:

fri: next Friday
+3d: three days from today
+2w: two weeks from today
nov 20: the 20th of November
2pm: today at two in the afternoon

S-left and S-right on a date move it a day back or forward, and S-up and S-down change whatever part the cursor is on, year, month, day or hour.

SCHEDULED and DEADLINE

Two kinds of dates mean something special to a task, and the difference is worth learning early:

* TODO Write the newsletter
SCHEDULED: <2026-11-09 Mon>
* TODO Send the tax documents
DEADLINE: <2026-11-20 Fri>

SCHEDULED means "this is when I plan to start working on it". DEADLINE means "this must be done by then". C-c C-s adds the first and C-c C-d the second. A deadline starts showing up in the agenda 14 days before the date, so it never catches you by surprise. You can change that window per task: <2026-11-20 Fri -5d> warns you only five days before.

Things that repeat

Add a repeater to a date and the task comes back after you mark it done:

* TODO Water the plants
SCHEDULED: <2026-11-09 Mon +1w>
* TODO Check the backups
SCHEDULED: <2026-11-09 Mon ++1w>
* TODO Change the water filter
SCHEDULED: <2026-11-09 Mon .+3m>

The three flavors behave differently when you're late:

+1w: moves exactly one week from the old date, even if that's still in the past
++1w: moves forward in steps of one week until it lands in the future
.+3m: moves three months from the day you actually did it

+ is good for bills, ++ for weekly rituals that should stay on the same weekday, and .+ for chores where the interval matters more than the calendar, like a filter that lasts three months from the day you changed it.

Dates that don't nag

Square brackets make an inactive date: [2026-11-06 Fri]. It's a note of when something happened, and the agenda ignores it. C-c ! inserts one. Org itself uses them for the CLOSED stamp and for logs.

The agenda: every file, one view

Up to here everything lived in one file. The agenda is where Org starts to feel like an app. It reads all your Org files and builds views out of them: what's scheduled this week, every open task, everything tagged :work:.

First, the agenda needs a key that works everywhere in Emacs. The Org manual suggests these three, and the rest of this post assumes you have them:

(global-set-key (kbd "C-c l") #'org-store-link)
(global-set-key (kbd "C-c a") #'org-agenda)
(global-set-key (kbd "C-c c") #'org-capture)

Second, the agenda needs to know which files to read. The simplest way is to keep all your Org files in one folder and point it there:

(setq org-agenda-files '("~/org"))

You can also add the file you're in with C-c [. Now press C-c a and a menu appears. These are the views you'll use most:

a: the agenda for this week, with scheduled items and deadlines
t: every open task, from every file
m: match tags, like work or travel+urgent
s: search for words across all your files

Living in the agenda

The agenda is a live view, so you can work from inside it without opening the files:

f / b: next or previous week
.: jump back to today
d / w: day view or week view
t: change the TODO state of the item under the cursor
C-c C-s / C-c C-d: schedule or set a deadline
RET: open the item in its file
TAB: open it in the other window
I / O: clock in or out (more on that below)
r: refresh the view
s: save all Org files
q: close the agenda

The first time you press C-c a a on a Monday and see your week laid out, with deadlines from three different files already sorted by day, Org stops being a text format and starts being a planner.

Your own views

When a view becomes a habit, give it a key. This one shows today's agenda with every task marked NEXT under it:

(setq org-agenda-custom-commands
'(("d" "Today and next"
((agenda "" ((org-agenda-span 'day)))
(todo "NEXT")))))

Now C-c a d is your morning page.

Capture: write it down before you forget

Ideas show up while you're doing something else. Capture lets you write them down without leaving what you're doing. Press C-c c from anywhere in Emacs, pick a template, type a line, press C-c C-c, and you're back where you were. The note went to the right file in the right shape.

Templates are short:

(setq org-capture-templates
'(("t" "Task" entry (file "inbox.org")
"* TODO %?\n%U")
("n" "Note" entry (file "inbox.org")
"* %? :note:\n%U")
("j" "Journal" entry (file+olp+datetree "journal.org")
"* %<%H:%M> %?")))

The little codes are placeholders. %? is where the cursor waits for you, %U is the current date and time as an inactive date, and %<%H:%M> is the time in whatever format you like. file+olp+datetree files each entry under year, month and day headings, which turns journal.org into a diary that organizes itself. A relative file name like inbox.org lives inside org-directory, the folder you set in the config.

Inside the capture window you have three choices:

C-c C-c: save it and go back
C-c C-w: save it somewhere else (refile, see below)
C-c C-k: never mind, throw it away

Refile and archive: keeping it tidy

An inbox only works if it gets emptied. C-c C-w on any heading (refile) asks where it should live and moves it there, children and all. With this in your config, the list of destinations includes every heading up to three levels deep in your agenda files:

(setq org-refile-targets '((org-agenda-files :maxlevel . 3)))
(setq org-refile-use-outline-path 'file)
(setq org-outline-path-complete-in-steps nil)

Finished projects can leave the stage too. C-c C-x C-a archives a heading: by default it moves it to an archive file next to the original, like inbox.org_archive. Nothing gets deleted, the agenda just stops seeing it.

One simple rhythm: capture everything into inbox.org during the week, then once a week open it, refile each item to its project, and archive what's done.

Links

Org links use double brackets, with an optional description:

[[https://orgmode.org][the Org website]]
[[file:~/org/projects.org][my projects]]
[[file:~/Pictures/rack.jpg]]
[[*Write the Org post]]

The last one points to a heading in the same file. When the description is there, Org shows only the description, underlined and clickable, and hides the brackets.

The keys:

C-c l: store a link to wherever you are (any file, any heading, even an email in Emacs)
C-c C-l: insert a link, or edit the one under the cursor
C-c C-o: open the link under the cursor
C-c &: go back to where you were before you followed it
C-c C-x C-v: show linked images inside the buffer

C-c l and C-c C-l together are the trick. Store a link to a heading deep inside some project file, go to your journal, press C-c C-l and the stored link is right there in the prompt. That's how a pile of files turns into a web of notes.

Tables that align themselves

Start a line with a pipe, type the column names separated by pipes, and press TAB:

|Item|Qty|Price|Total|
|-

Org aligns the columns. The second line, a pipe and a dash, turns into a separator line when you press TAB on it. From then on, TAB jumps to the next cell and RET to the next row, and the table realigns itself as you type. You can write as messy as you want.

Moving and changing the table uses the same keys as headings, which is a nice touch:

M-left / M-right: move a column
M-up / M-down: move a row
M-S-right: insert a column
M-S-left: delete a column
M-S-down: insert a row
M-S-up: delete a row
C-c -: insert a separator line below
C-c ^: sort by the current column

Formulas

Tables can calculate. Here's a small shopping list:

| Item | Qty | Price | Total |
|-
| Coffee | 2 | 18 | |
| Bread | 3 | 7.5 | |
| Cheese | 1 | 32 | |
|-
| Total | | | |
#+TBLFM: $4=$2*$3::@>$4=vsum(@2..@-1)

Put the cursor on the #+TBLFM line and press C-c C-c. The Total column fills in with 36, 22.5 and 32, and the last row adds them up to 90.5.

The formula reads like this. $4=$2*$3 says "column 4 is column 2 times column 3", for every row. After the double colon comes a second formula: @>$4 is the last row, column 4, and vsum(@2..@-1) sums from row 2 to the row above. Change a price, press C-c C-c again, and everything updates.

You don't have to learn the syntax by heart. In any cell, C-c = asks for a formula for that column, and C-c + adds up the numbers in the column above and shows the result. For anything bigger, Org's tables can use Emacs Calc or Lisp in formulas, but the basics carry you a long way.

Properties and column view

Any heading can carry a drawer of key and value pairs:

* TODO Replace the NAS disks
:PROPERTIES:
:Effort: 2:00
:Cost: 1200
:END:

C-c C-x p adds a property with completion, and C-c C-x e sets the effort estimate. On their own, properties are just tidy metadata. Combined with column view, they become a spreadsheet of your outline. Add this line at the top of the file:

#+COLUMNS: %40ITEM %TODO %Effort %Cost

Then press C-c C-x C-c on a heading. The outline turns into a table, one row per heading, one column per property, and you can edit values right there. q goes back to normal.

Clocking time

Org can tell you where your hours went. On a task, press C-c C-x C-i to start the clock. The mode line at the bottom of Emacs shows the task and the running time. C-c C-x C-o stops it. Org writes the session under the heading:

* TODO Write the Org post
:LOGBOOK:
CLOCK: [2026-11-06 Fri 09:10]--[2026-11-06 Fri 11:25] => 2:15
:END:

A few related keys:

C-c C-x C-j: jump to the task that's being clocked
C-c C-x C-q: cancel the current clock
C-c C-x C-d: show the total time on every heading
M-x org-clock-report: insert a table with totals per task

The clock report is a block that updates with C-c C-c, so a monthly "where did my time go" is one key away. In the agenda, I and O clock the item under the cursor in and out.

Code blocks: a notebook in plain text

This is where Org goes past what a note app does. An Org file can hold code, run it and keep the output:

#+begin_src shell :results output
df -h /
#+end_src

Put the cursor inside and press C-c C-c. Org runs the command and writes the result right under the block, in a #+RESULTS: section. Run it again and the result is replaced.

Out of the box, only Emacs Lisp runs. To enable other languages, list them in your config:

(org-babel-do-load-languages
'org-babel-load-languages
'((emacs-lisp . t)
(python . t)
(shell . t)))

Now Python works the same way:

#+begin_src python :results output
print(2 + 2)
#+end_src

#+RESULTS:
: 4

A few things that make code blocks pleasant:

C-c C-,: insert a block from a menu (src, quote, example and more)
C-c ': edit the block in a full buffer for that language, then C-c ' again to come back
C-c C-c: run the block under the cursor
C-c C-v t: write all blocks marked with :tangle into their own files

That last key is the start of what people call literate configuration. You write your Emacs config, your shell scripts or your server notes as an Org document, with explanations between the code, and add :tangle to each block:

#+begin_src shell :tangle ~/bin/backup.sh
rsync -a ~/org/ server:/backups/org/
#+end_src

C-c C-v t writes the code out to the real files. The documentation and the code can't drift apart, because they're the same file.

If you prefer typing to menus, add (require 'org-tempo) to your config. Then <s followed by TAB expands into a source block, <q into a quote, <e into an example.

When Org asks "Evaluate this code block?" before running anything, that's on purpose. A file you download could contain code, and Org won't run it without asking.

Export: from text to HTML, PDF and friends

C-c C-e opens the export menu. Each letter picks a format, and a second letter picks what to do with it:

h h: HTML file
h o: HTML file, then open it in the browser
l p: PDF, through LaTeX
l o: PDF, then open it
o o: OpenDocument text (.odt), which LibreOffice and Word open
t U: plain text with Unicode, in a buffer

PDF export needs a LaTeX installation on your computer, such as TeX Live. HTML and ODT need nothing extra.

Markdown is not loaded by default. Add (require 'ox-md) to your config and m m appears in the menu.

A few lines at the top of a file control the export:

#+TITLE: A trip to Ouro Preto
#+AUTHOR: Your name
#+DATE: 2026-11-06
#+OPTIONS: toc:nil num:nil ^:{}

toc:nil removes the table of contents, num:nil removes the numbers in front of headings, and ^:{} stops Org from turning file_name into "file" with a subscript "name", which gets in the way when you write about code. In the export menu, C-s limits the export to the heading under the cursor, handy for sending one section of a big file.

Code blocks export only the code by default. Add :exports both to a block to include its result, or :exports results to show only the output.

Small things worth knowing

Footnotes. C-c C-x f creates a footnote like [fn:1] and takes you to where its text goes. Press it again on the reference to jump back.

Focus on one section. C-x n s narrows the buffer to the current heading, so the rest of the file disappears. C-x n w brings it back. Great for writing long things.

Jump to any heading. C-c C-j lets you search the outline and go straight to a heading.

Sparse trees. C-c / opens a menu that folds the file to show only what matches. C-c / t shows only open tasks, C-c / m matches tags, C-c / r matches a regular expression. Everything else folds away until you press S-TAB.

Notes on a task. C-c C-z adds a dated note under the heading. Useful for "called them, they'll answer on Monday".

A cleaner look. (setq org-startup-indented t) indents text to match its heading, without changing the file. The stars of deeper levels become invisible except the last one.

Special characters. Type \alpha or \rarr and Org shows α and → if you set (setq org-pretty-entities t). The file still holds the plain backslash version.

A starter config

Here's everything from this post in one place. Put it in your init.el, change the folder if you want, restart Emacs, and create ~/org if it doesn't exist:

;;; Org mode, a starting point

(require 'org)
(require 'org-tempo) ; <s TAB for code blocks
(require 'ox-md) ; Markdown export

;; Keys that work everywhere in Emacs
(global-set-key (kbd "C-c l") #'org-store-link)
(global-set-key (kbd "C-c a") #'org-agenda)
(global-set-key (kbd "C-c c") #'org-capture)

;; Where your files live
(setq org-directory "~/org")
(setq org-default-notes-file (expand-file-name "inbox.org" org-directory))
(setq org-agenda-files (list org-directory))

;; Task states: open ones before the bar, finished ones after
;; The letters are shortcuts; @ asks for a note when you pick that state
(setq org-todo-keywords
'((sequence "TODO(t)" "NEXT(n)" "WAIT(w@)" "|" "DONE(d)" "CANCELED(c@)")))

;; Record when tasks are done, and keep logs folded in a drawer
(setq org-log-done 'time)
(setq org-log-into-drawer t)

;; Capture
(setq org-capture-templates
'(("t" "Task" entry (file "inbox.org")
"* TODO %?\n%U")
("n" "Note" entry (file "inbox.org")
"* %? :note:\n%U")
("j" "Journal" entry (file+olp+datetree "journal.org")
"* %<%H:%M> %?")))

;; Refile anywhere up to three levels deep
(setq org-refile-targets '((org-agenda-files :maxlevel . 3)))
(setq org-refile-use-outline-path 'file)
(setq org-outline-path-complete-in-steps nil)

;; A custom agenda view: C-c a d
(setq org-agenda-custom-commands
'(("d" "Today and next"
((agenda "" ((org-agenda-span 'day)))
(todo "NEXT")))))

;; Looks
(setq org-startup-indented t)
(setq org-pretty-entities t)

;; Languages for code blocks
(org-babel-do-load-languages
'org-babel-load-languages
'((emacs-lisp . t)
(python . t)
(shell . t)))

With TODO(t) and friends in the keywords, C-c C-t stops cycling and shows a small menu instead: press t, n, w, d or c to jump straight to a state. If Python code blocks complain that python doesn't exist, your system probably calls it python3, and (setq org-babel-python-command "python3") fixes that.

A way to start

The worst way to learn Org is to set up everything on the first day. A gentler path:

1. Week one: one file. Keep a single notes.org. Use headings, TAB, lists and M-up/M-down. Nothing else.
2. Week two: tasks. Add TODO, C-c C-t, SCHEDULED and DEADLINE. Open the agenda with C-c a a every morning.
3. Week three: capture. Set up one template and use C-c c for every idea, task and link that shows up.
4. Later, as needed. Tables when you need numbers, code blocks when you need to run something, export when you need to send something to someone.

Every feature in Org is optional. A file with three headings and a TODO is already a perfectly good Org file.

Org outside Emacs

Plain text travels well, and Org files are read by more programs than people expect:

• GitHub, GitLab and Gitea render .org files on the web, the same way they render Markdown.
• Pandoc converts Org to and from Markdown, Word, HTML, EPUB and many other formats.
• On Android, Orgzly Revived reads and edits Org files, with saved searches and reminders. It's on F-Droid.
• On iOS, beorg does the same, with a to-do list and an agenda.
• In Neovim, nvim-orgmode brings a good part of Org to Vim users.

Put your ~/org folder in whatever sync you already trust, and the same files follow you from the desktop to the phone.

Cheat sheet

Structure:

TAB: fold or unfold the heading
S-TAB: fold or unfold the whole file
M-RET: new heading or list item
C-RET: new heading after the current section
M-left / M-right: promote or demote
M-S-left / M-S-right: promote or demote with children
M-up / M-down: move the section
C-x n s / C-x n w: narrow to the section / show everything again
C-c C-j: jump to a heading

Tasks and dates:

C-c C-t: change the TODO state
S-left / S-right: cycle the state (or move a date)
S-up / S-down: change the priority (or the date part under the cursor)
C-c C-q: set tags
C-c C-s: schedule
C-c C-d: deadline
C-c .: insert a date
C-c !: insert an inactive date
C-c C-c: tick a checkbox, update a cookie, recalculate, run code (it does the right thing for where you are)
C-u C-c C-c: turn a list item into a checkbox

Agenda, capture and links:

C-c a: open the agenda menu
C-c c: capture
C-c C-w: refile
C-c C-x C-a: archive
C-c l: store a link
C-c C-l: insert or edit a link
C-c C-o: open a link

Clock, code and export:

C-c C-x C-i: clock in
C-c C-x C-o: clock out
C-c C-,: insert a block
C-c ': edit a code block in its own buffer
C-c C-v t: tangle code blocks into files
C-c C-e: export menu

Where to go from here

The Org manual is inside Emacs: press C-h i, then look for Org Mode in the list. It's long, well written and full of examples, and it's also online at orgmode.org/manual. Worg, the community wiki on the same site, has tutorials, configs and ideas from people who have been using Org for years.

And when you forget a key, remember the one key that never changes in Org: C-c C-c almost always does what you meant, wherever the cursor is.