More personal computing

Many years ago, there was something called The Toaster Project. The crux of the project was demonstrating the complexity underlying basic items we take for granted. In The Toaster Project, the goal was to replicate a cheap, mass-manufactured toaster through the efforts of an individual, using locally-sourced materials (in this case, "local" meant the United Kingdom). It was a cool project, and a real cultural touchstone in 2009, when it invited those encountering it to think about the dependencies required for the production of something so basic as a toaster. It spawned a TED talk and the toaster is now in the collection of the Victoria and Albert Museum.

In 2026, it's been a sad year for Free/Libre and Open Source Software (a reminder of what F/LOSS is and why it matters, should you need such a thing) – if you prefer your source code to be written by humans, and if you think ethics are important. It seems like a stream of important F/LOSS projects are revealing either a tolerance or a preference for code generated by large language models (LLMs) leading those of us who prefer to not use the outputs of generative AI wondering what we should be using for such software basics as operating systems and word processors. This is stirring itself up into a storm in which a lot of people start saying the quiet part out loud in terms of their own attitudes towards the ethics of software development and use. Things some of us have been promoting as not only technically superior, but more ethical and more accountable, are now falling prey to the lure of vibecoding and very sketchy justifications. It's a tough year if you're invested in and concerned about the provenance of your software.

This is where a small, personal though experiment emerges. How small and constrained would I have to make my computing environment in order to only use software small enough to not fall victim to the whims of arbitrary developers with bad takes? Basically, how personal do I have to make my computing to be able to feel that I can trust developers of any given piece of software to continue to develop things themselves, without the intervention of "AI?" In essence, a Toaster Project, but for software. (With a hat tip to the many people out there working on various kinds of minimal and alternative computing. There's quite a decent number of them, but two examples that spring immediately to mind are Brendan Howell's Screenless Office project and the excellent solar web design of the crew behind Low-tech magazine. These are different angles, but both wonderful and inspiring projects.)

Two caveats

Two caveats go with this thought experiment. The first is that it's really a thought experiment. It's a thought experiment for many reasons, not least of all because I acknowledge the essential impossibility of doing this exercise in real life. I'll go into more detail on that a little further along in this essay. It also wouldn't be an earnest attempt, even if it were technically possible, because I'm much more interested in systemic change than in making a small, comfortable corner for myself, dependent on like-minded people. Now is the time to be promoting ethical approaches to software development more widely, not retrenching and pulling away. There's a hard fight ahead, and it's something that needs as many committed people as it can get.

The second caveat is that I'm not addressing the production of hardware here, and I'm also ignoring the question of specialized software essentially baked into hardware. I'm starting, instead, from the other end – thinking about my own use of a computer (not a phone, which is a whole other problem) and working backwards for a while from that. I'm making these choices because I want to think about the user-facing side of things, and because this is a whimsical thought experiment, not a true attempt at moral purity in my computing environment – which would have an awful lot more dependencies.

Minimum viable computing

How small and specific can I make my computing environment? What would it take to continue to be able to do my most important computing tasks, while relying on tools small enough to conceivably be made by people I do already or could directly know? (This is going to be my basis for trust: can I personally talk to and trust a sufficient number of people in the given software project.) My two personal biggest use cases for computing are creating documents in a word processor, and browsing the web. I do many other things with a computer aside from those two, but they're the ones that I spend most of my computing time on.

Obviously, I could replace the word processor with a typewriter and not compute at all. But then I'd lose the additional functionality that a word processor gives me over handwriting or typewriting. But the experiment fails here already: I don't personally know any wild and wonderful small groups of F/LOSS developers making a full-featured word processor. While it's conceivably possible, there are an awful lot of dependencies baked into that proposition that would need to be addressed. But what if I scale it back? What if I'm willing to take something simpler, something that can save and edit text, maybe handle some basic formatting, but not do things like export a PDF file (because that creates a whole pile of new reasons to rely on other projects and their developers) or, say, track changes or run spellcheck. That would likely be enough for a lot of my use cases, but certainly not all of them. Doing my job would suddenly involve a lot more friction, as I often have to handle files that are full of tracked changes. So if I want to collaborate with my colleagues, I need a word processor that can do all the things MS Word (or whatever it's called now) can do, since most of my colleagues are operating in that world.

And if I go it alone, instead? If I expand the thought experiment to, say, only seeking accountability in my personal computing, and throwing it all away when I go to my job? I guess I could then just write plaintext, and use HTML or Markdown if I want to introduce formatting and text styling. Let's say I go the HTML route. Now I need a text editor (something I can write an HTML file in) and a browser (something to view an HTML file in). And I also need, of course, for the complex and multi-stakeholder standards-setting process which defines the HTML standard to be trustworthy and accountable and not use AI in their processes. Given the function that companies with a stake tend to have in the standards process, this feels unlikely even in the short term. But let's hand-wave away the issue of standards for the moment.

So I need a text editor and a browser. Convenient that the thing I need to view my texts is also what I need to browse the web. The web as we know it now has an awful lot going on, and its complexity once again makes it too big and too diffuse to really be able to be certain that everything I'm using holds up to scrutiny. And that's only thinking about the things I need to install on my computer, not what's creating the functionality of any given website I visit. Only on my own end, I need account for the engine under my browser, any number of libraries and APIs, and all the other bits and pieces that make looking at complex modern websites feel seamless. That's not going to be achievable within a small circle of trust, because many of those are very big projects, and some of them include the intervention of big web companies. But as we established in the previous paragraph, it's all a bit of a moot point, as the web relies on standards to function, and I'll need to trust the standards-setting process that makes and institutionalizes decisions about things like HTML. So we're back at square one. The best expectation I can have is to use a very minimal web browser, only to view files on my own computer. Which at least fits the use case of viewing formatted text. But it certainly doesn't help me browse the modern web.

What if it's really small

Let's say we abandon the idea of browsing the web. Even if all I want to do in terms of computing is basically just have a slightly advanced typewriter, I'll need an operating system. Something needs to run my text editor and take care of my filesystem. This, I think, is maybe feasible. I know some really excellent maniacs (maniacs in the best possible way) who've dabbled with this kind of thing over the years. So maybe I can get a really old computer. And maybe I can run a reeeeaaallly tiny, old version of Linux that isn't at the mercy of current development trends (looking at you, HAL 91). I'd have a text editor (not a word processor, I'll grant you, and very much not a browser). I'd have a terminal. I'd have incredible moral superiority and the capacity to believe that, if I'm working with something that never gets updated, and that I never let on the internet, then the current and future personal preferences of the software's maintainers don't have to worry me. And then what?

It would be admittedly cool. But I'd be walking myself into a corner. As with The Toaster Project, the exercise of figuring out what minimum viable computing would mean for me is not an exercise in really trying to do it, but in considering what my own computing depends on. And of course, the things I do most are highly dependent on standards, libraries, and programming languages that other humans, mostly ones I don't personally know, make individual and collective decisions about. I can (and do – this is why I'm an advocate of F/LOSS) make decisions about my computing that are based on my own ethics, but the changing attitudes in software development right now make it quite hard to stay standing on the shifting sands of norms and morals when it comes to code.

Now what?

I land at a bit of an impasse. It's potentially possible to compute in small and creative ways, and to make sacrifices and tailor my use cases to tiny and reliable systems. But, to bring in the toaster parable, there's no bagel setting on the simplest possible toaster. And there are always more dependencies to look out for. Eventually, I'll run into a layer of the system that compromises the values of short lines, transparency, access, or whatever other ways I want to define acceptability. And then what? Given that I intended this essay as a slightly light-hearted attempt to think through current problems in the F/LOSS ecosystem, rather than falling into despair, this last "and then what?" had better be pretty good.

So. Then what? First, we need to be less complacent. This "we" is people who want to think about software as something that should be developed within specific ethical frameworks. We need to not assume that everyone doing the F/LOSS thing is doing it for the same reasons. We need to be yet more serious about our communities and their norms. We need to foreground the ethics and the politics, and be more vocal about the need for political commitments in the way we organize ourselves. This is already happening in some corners, and is worth emulating. One of the mistakes the activist and ethics-first side of F/LOSS has made over the years is to be content with arguments about technical and legal superiority. (Fair enough: the leading lights of our movement have been pushing those things. The mainstream of the movement has accepted those things.) Those arguments are easy to co-opt, and they're not perfect stand-ins for saying that we want software made with our values in mind. We need to put our values first. We need to create frameworks for F/LOSS that are about accountability and community (not "accountability" and "community" in the ethics-washing senses they're often used in). And then we need to codify those values, run our projects by them, and enforce them.