Notes ·
Worth Wandering: Hundred Rabbits
Joshua MorrisTwo artists living aboard a sailboat, building games, software, comics, and cooking knowledge around computers that stay understandable when power and the internet are not assumptions.
I knew about Hundred Rabbits before I started wandering through the site for this note. I had seen Uxn mentioned a few times, knew there were some interesting tiny-computing projects around it, and recognized the distinctive black-and-white artwork, so I assumed I already understood the shape of the project. That assumption did not survive the first real visit. The site kept opening into another room, another practice, another decade of work, and by the time I stopped clicking I realized how incomplete my earlier picture had been.
The problem with explaining Hundred Rabbits is that every reasonable description leaves out most of it. It looks like a software project until you find the games. It looks like an art project until you start reading about Uxn. It looks like a sailing site until you end up learning Morse code from illustrated rabbits living aboard vegetable-shaped boats. There are recipes, programming languages, music tools, photography, books, zines, boat repairs, fermentation experiments, and years of notes connecting all of it together, which is why I spent a lot more time wandering around than I intended. For a place this crowded with curiosity, that overstay feels exactly right.
They live where the constraints are real
Hundred Rabbits is Rek Bell and Devine Lu Linvega. Rek is an illustrator and writer, Devine is a programmer and musician, and they live and work aboard Pino, a Yamaha 33 sailboat built in 1982. They purchased the boat on Vancouver Island in 2016 and have since sailed across large parts of the Pacific, including Mexico, New Zealand, Fiji, Japan, Alaska, and western Canada. That biography matters because their software philosophy did not begin as a desk-bound argument that computers ought to be more minimal. It grew out of a life in which the usual assumptions about power, connectivity, and replaceable hardware stopped being true.
Living aboard a sailboat changes the requirements in ways that are easy to underestimate from shore. Electricity is something they collect from the sun and store in batteries. Internet access can disappear for days. Downloading several gigabytes of updates is not a trivial inconvenience when connectivity is limited. Hardware needs to last, and replacing something does not necessarily mean having another one delivered tomorrow. Rek and Devine have talked about how those constraints gradually pushed modern software out of their lives: tools that depended on constant connectivity became unreliable, large development environments became difficult to maintain, and updates could break things that had previously worked perfectly well. The problem was no longer theoretical. Their computers were failing them because the software assumed a world they did not live in.
Most software developers who reach that conclusion write an angry blog post about Electron. Hundred Rabbits built a computer. I respect that escalation because it came from necessity rather than fashion. They did not start with an ideology and then search for evidence that supported it. They had an actual problem, modern computing had accumulated assumptions that stopped making sense aboard Pino, and they started removing those assumptions. The result eventually became something much more interesting than merely using old laptops.
The art is part of the system
It would be easy to write about Hundred Rabbits entirely through the technology, especially once you get into Uxn, but that would miss one of the things that makes the whole project work. The art is not a coat of paint on top of the engineering. It is one of the ways the place thinks, teaches, and holds together.
Rek's illustrations are everywhere: strange rabbits, sailors, machines, sea creatures, tiny rooms, boats, symbols, tools, landscapes, and characters that look like they wandered out of some book you vaguely remember reading as a kid but can no longer prove existed. The style carries across projects without making everything look identical. Technical documentation can sit beside an illustrated rabbit and somehow the rabbit does not feel like decoration someone added later to make the documentation friendlier. It belongs there, probably because the separation between engineering and art does not seem particularly important to Hundred Rabbits. They describe themselves as two people who like creating worlds. Rek builds those worlds through illustration and writing, while Devine uses software and music to make parts of them interactive.
You can see that philosophy once you start looking for it. A game is not separate from the drawings that define its world. A manual can become a zine. A programming environment can have a visual identity. A technical diagram can still be beautiful. Documentation does not have to look like documentation just because it contains accurate information. I spend most of my working life around software where design systems exist to make hundreds of things appear consistent, and Hundred Rabbits achieves a stronger sense of identity with hand-drawn rabbits, black-and-white artwork, and what appears to be an almost complete refusal to make anything look like SaaS. I think they may be onto something.
Oquonie is a good place to understand how this all comes together
Oquonie is a textless isometric puzzle game that Rek and Devine originally started while they were living in Japan. They were navigating a new country where language could regularly become an obstacle, and they turned some of that experience into a game about being lost in a foreign place. You move through what feels like an endless collection of interconnected rooms while encountering strange characters who speak a language you do not understand. The game was also influenced by Junji Ito's A Town Without Streets, which helps explain the feeling that the world continues beyond what you can currently understand or see.
The artwork is beautiful. The rooms look like little architectural drawings that somehow became explorable. The characters are weird without feeling like they are working very hard at being weird, and the limited palette leaves the illustration itself doing most of the work. More importantly, the game trusts you to figure things out. A lot of modern software is terrified that a person might spend five seconds without knowing exactly what to click next, and Oquonie is basically built around that feeling. Being lost is not a usability bug someone forgot to fix. Being lost is what the game is about, and there is something I like about that kind of confidence.
Oquonie also became a clear example of why Hundred Rabbits started questioning the software stack beneath their work. They originally developed it for iOS, but by 2018 repeated breaking updates and the growing Xcode development environment had become increasingly incompatible with their life at sea. They eventually removed the game from Apple's store. In 2023 they rebuilt Oquonie as a Varvara ROM using their own Uxn ecosystem so the game could exist on a much smaller and more portable foundation, and it has since made its way onto the Playdate as well. I love this story because the response to software decay was not simply trying harder to keep the old environment alive. They changed the environment. They built something small enough that they could understand it, carry it forward, and then brought their game with them.
Then there is Uxn
Uxn is where I originally knew Hundred Rabbits from, and it is probably the deepest technical rabbit hole on the site. Uxn is a tiny virtual machine programmed using a language called Uxntal. Hundred Rabbits describes it as the "ordinator" at the center of their ecosystem and, more importantly, as a portability layer for keeping small graphical programs alive across different computers. Their own XXIIVV wiki runs on it, which makes the idea feel less like a manifesto and more like a machine they actually inhabit.
The idea is simple enough that I immediately found myself thinking about it. Software preservation usually means preserving increasingly complicated environments. We keep adding layers of compatibility so an old program can continue pretending it still lives inside the computer that originally ran it. Hundred Rabbits went the other direction: make the machine being preserved very small, then future computers only need to reproduce that small machine. Uxn implementations already exist for multiple environments, including X11, SDL2, Windows, and the browser. Programs target Uxn rather than depending directly on whatever giant collection of APIs happens to define a modern desktop at the moment.
I don't think the point is that everybody should throw out their existing operating system and start writing Uxntal. I certainly have enough strange technology projects already. What interests me is the question underneath it: how small can we make the part that actually matters? That question shows up all over Hundred Rabbits. Better software, in their view, should be capable of becoming smaller over time rather than constantly requiring more powerful hardware. Old machines are not automatically obsolete because a newer machine exists. Software should be understandable enough to repair without its original author standing beside you. Those are ideas I find hard to argue with even while sitting here surrounded by computers that could probably simulate Pino's entire electrical system just to animate a loading spinner.
Orca makes programming look alive
Orca is another project I had seen before but never spent enough time actually exploring. It is a two-dimensional livecoding language and virtual machine. Every letter of the alphabet acts as an operator on a grid. Lowercase and uppercase letters behave differently, operators interact with neighboring cells, values move through the space, and the resulting system can generate music and MIDI. Describing it makes it sound more intimidating than actually watching it.
An Orca program looks somewhere between source code, a spreadsheet, a sequencer, Conway's Game of Life, and the control panel of a machine that probably should not be left unattended. Things move around. Letters trigger other letters. Values travel across the grid. Patterns emerge. The program has a spatial quality that most source code does not, because you can watch it doing something rather than merely reading instructions and imagining how control is moving through them.
The Orca page also shows how Hundred Rabbits approaches documentation. There is an interactive playground embedded directly in the page, an operations manual, examples, tutorials, a printable zine, and several implementations of the environment. They did not make a tool and then begrudgingly write documentation because someone opened an issue asking for it. Learning the tool is part of the project, and that care shows up repeatedly across the rest of the site.
Rabbit Waves may be the part I enjoyed wandering through most
At some point I found Rabbit Waves and temporarily forgot I had started this whole thing by reading about a virtual machine. Rabbit Waves is an illustrated project for teaching practical analog and maritime knowledge. The main character, Hazy, is a rabbit living aboard a giant turnip-shaped sailboat, and other characters travel around in similarly improbable vessels. That premise alone would have been enough to keep me there for a while.
The clever part is how the site uses the comic itself. Colored objects inside the illustrations are links. A story about a rabbit making coffee can lead into information about rainwater collection, filtration, food storage, cast-iron cookware, or whatever else appears in the scene. Other parts of the project teach Morse code, maritime signal flags, emergency preparation, celestial navigation, boatswain's calls, and pen-and-paper ciphers. The artwork becomes the interface, and that is such a good idea that I am a little annoyed I did not think of it first.
Instead of starting with a category tree labeled "Maritime Knowledge," Rabbit Waves starts with somebody living a life. Hazy wants coffee. Another boat approaches. Somebody needs to communicate. Somebody needs to know where they are. The information appears because the characters need it, which gives practical knowledge a context instead of a syllabus. Rek's illustrations make this work because the scenes reward looking closely: shelves contain things, boats look used, jars are wrapped so they do not smash around underway, and tools have places to live. There are little details everywhere that make these ridiculous vegetable boats feel strangely believable. The material is still being expanded during 2026, including new comic pages and knowledge sections on pen-and-paper ciphers. I went there to see how the project worked and ended up reading about signal flags, which is exactly what Wander is supposed to do to me.
Of course there is also a cooking site
Because apparently building a virtual machine, making games, drawing comics, sailing across the Pacific, making music, and maintaining a giant wiki left a little room in the schedule, Hundred Rabbits also has Grimgrains. Grimgrains started in 2014 as their food and cooking resource. It includes recipes and information about food resilience, with a particular interest in fermentation. At first that can feel like another branch bolted onto the tree, until you spend enough time with the rest of their work and realize how cleanly it fits.
The same questions keep appearing. What can we make ourselves? What can we preserve? What works without a complicated supply chain? What requires less energy? What can we understand well enough to repair or reproduce? Sometimes the answer is a virtual machine. Sometimes the answer is fermented food. Their 2026 updates move between these worlds without treating the transitions as particularly unusual, so one update can include an improved Uxn bootstrap process, a new Rabbit Waves comic, work on Oquonie, changes to a boat system, and a new Grimgrains recipe. I like that. Real life does not arrive with Jira labels. You can spend the morning debugging something and the afternoon fixing a water tank because the water tank does not care what sprint you are in, and Hundred Rabbits documents the whole thing.
XXIIVV is where you can really get lost
If Hundred Rabbits is the workshop, XXIIVV feels like opening all of the drawers. Devine has been building the wiki for years, and it contains programming languages, software, games, music, photography, boat information, experiments, books, notes, diagrams, and enough cross-links to destroy any realistic plan you had for the afternoon. I mean that as praise. This is one of the things I miss about the web.
A lot of modern websites work very hard to predict the next thing you want and make sure you reach it with the fewest possible clicks. There are good reasons for that when I am trying to buy dog food or pay the electric bill. A personal site does not need to behave like that. XXIIVV rewards curiosity instead. You follow one term because you do not know what it means. That page links to another project. The project links to a log entry. The log mentions a tool. The tool was used to make a game. Now you are reading about an obscure programming language from decades ago and have forgotten why you originally arrived. That is not bad information architecture for this kind of site. I think it may be the point.
Hundred Rabbits also maintains photography, travel records, boat information, software histories, journals, and connections into projects such as Merveilles. The boundaries between the projects become increasingly fuzzy the longer you explore them. Eventually you stop thinking of these as separate websites. They are pieces of the same place.
This is not an abandoned corner of the old web
The age and visual style of some of these projects might make Hundred Rabbits look like something preserved from an earlier period of the web, but it is not an archive that simply survived. They are still working on it. Their 2026 updates include new Rabbit Waves pages, continued Oquonie work, Uxn improvements, new Grimgrains material, changes to their books, work on Donsol, new emulators, experiments with older programming ideas, and the ordinary maintenance required to keep Pino moving and livable. That matters to me because I like old websites, but I like living websites more. There is a difference between visiting an archive that has survived and visiting a place where somebody is still turning on the lights, moving things around, adding another page, and occasionally repairing the plumbing. Hundred Rabbits feels inhabited.
Open source means something a little different from a sailboat
One of the most interesting explanations I found came from an interview Rek and Devine did with Drew DeVault at SourceHut. They explained that they work largely offline and cannot assume they will always be available to help someone use or repair their software. They may be away from connectivity for days or weeks at a time, so their code needs to be inspectable and repairable without them being present. Rek gave an even simpler reason for making the work open: they do not want the projects to die with them. I think that is worth sitting with for a moment.
Software increasingly depends on its creator continuing to exist as a company. The application needs an authentication server, subscription system, cloud API, update service, or some other piece of infrastructure that nobody using the software actually controls. If the company disappears, perfectly good software can turn into a very elaborate error message. Hundred Rabbits approaches ownership differently. The code should be able to speak for itself. Someone else should be able to understand it, repair it, and pick it up if the original creators no longer can. Living aboard a boat makes those requirements immediate, but I don't think you need to be halfway across the Pacific to see their value.
What I would improve
The hardest part about Hundred Rabbits is figuring out what Hundred Rabbits actually contains. I originally knew it as the Uxn people. Somebody else may find Oquonie and think of them as game developers. Another person might arrive through Rabbit Waves, Grimgrains, Rek's artwork, Devine's music, or one of the sailing logs. All of those descriptions are correct, and all of them are incomplete. Once I understood how the pieces related to one another, that confusion became part of the fun. Before that, I was not always sure whether I had wandered into another project, another site, another person's work, or another entrance into the same project.
I would not fix that by turning the homepage into a corporate portfolio with a hero statement, twelve project cards, testimonials, and a large button asking me to schedule a demo. Please don't do that. What I would love is a map — not a conventional sitemap, but an actual Hundred Rabbits map. Put Pino in the middle. Draw Uxn somewhere below deck. Let Rabbit Waves sail off toward one side, Grimgrains live near the galley, Oquonie occupy some impossible rooms, and connect XXIIVV, Orca, Kokorobot, the games, music, books, photography, and everything else around them. The art is already there. The world is already there. I just want to see the map.
What do we actually want computers to do?
After spending time with Hundred Rabbits, this is the question I kept coming back to. Most discussions about computers begin with what computers are capable of doing. Hundred Rabbits seems more interested in what computers are worth using for, and that is a much more interesting question. Computers can help them write, draw, make music, build games, preserve knowledge, communicate, navigate ideas, and create tools they actually own. Those tools do not need to consume every available resource simply because the resource exists. A newer computer does not automatically make an older one useless. A program does not need to become a service. An application does not become better simply because it has acquired another thousand dependencies. And sometimes the right amount of technology for a problem is less technology.
That does not make Hundred Rabbits anti-computer. The evidence is everywhere that they love computers. They care enough about them to ask what kind of relationship they actually want to have with them, and I think that is the part I find most interesting. The constraints did not make their world smaller. Look at the artwork, the games, the music, Rabbit Waves, the books, the photography, Orca, Uxn, the food, the sailing, and years of documentation. It is overflowing with things they have made. What the constraints seem to have done is give all of that work a shape.
Hundred Rabbits is not a sailing blog with some code attached. It is not an art portfolio with a strange virtual machine in the basement. It is not a retrocomputing project pretending computers peaked forty years ago. It is two people building the tools and worlds they want to live with, documenting what they learn along the way, and leaving enough of it open that other people can wander in and learn something too. That is what makes the site so much fun to explore. I arrived because I wanted to understand Uxn a little better. I left knowing how a rabbit on a turnip-shaped sailboat collects rainwater and makes coffee. The web needs more paths like that.
Worth wandering because: Hundred Rabbits is what happens when art, software, sailing, practical knowledge, and years of curiosity are allowed to grow together instead of being separated into products.