This essay was written with Nathan E. Sanders, and originally appeared in The Guardian.

OpenAI, and then Anthropic, were each formed by AI developers who feared unrestrained corporate AI development—specifically, that companies like Google and Meta would steer the technology towards deleterious, maybe even catastrophically unsafe, outcomes for society. Their founders proclaimed that their new labs, uniquely, could be trusted to develop the technology in humanity’s best interest. But each, in turn, were themselves co-opted by the same market incentives, themselves becoming corporate behemoths zealously guarding future investor value rather than the public interest.

It was only a few weeks ago, in June, when OpenAI and Anthropic each filed for their IPOs and were met with buzz about trillion-dollar valuations. The hype around their valuations is so extreme that many worry about their potential for concentrating wealth on a global scale. In an effort to leave something for the rest of us, some observers have proposed that the federal government seize a share of these companies’ stock to create a US sovereign wealth fund, or redistribute their revenues to produce a dividend for taxpayers.

Now the headlines are about public backlash to AI datacenters and the AI chip giant Nvidia’s slumping stock. The tech and AI giant SpaceX’s newly minted stock price tanked just weeks after its IPO. There are even questions about whether the leading AI labs will ever be sustainably profitable. All of a sudden, the makers of ChatGPT and Claude face strong headwinds as they seek to generate the massive equity assets that once felt all but assured.

In fact, evidence suggests the market itself could reassess that these companies offer nothing of financial value. In that case, perhaps we can return them both to their original purposes. If these AI companies should fail in the financial markets, the US should nationalize them and convert them into national labs operated under democratic control that preserve their benefit to the public interest.

The economics of the big AI labs hardly guarantee a booming return on investment. Frontier AI models are both expensive to train and depreciate within months, when a newer model appears. This means that the payback window to extract profit from them is very narrow. Meanwhile, enterprise clients are getting smart about minimizing AI token usage. Even worse, the models are basically commodities; the best ones largely perform and behave similarly, which depresses prices. Perhaps most importantly, open-source and Chinese competitors—lagging only a few months behind the leading labs in capability—give away for free the kinds of models Anthropic and OpenAI sell.

Even setting aside the model training costs, it’s not clear whether the unit economics of AI as it’s currently conceived will ever be sustainably profitable. Many of these free and open-source models can be run locally: the large ones on private clouds and high-end servers, the smaller ones on anyone’s laptop or even cellphone, putting to question the companies’ exorbitant capital investment in datacenters.

It’s not that OpenAI and Anthropic are not valuable as organizations. They have remarkably talented AI scientists and engineers that are continuously producing innovations driving a global mania for their offerings. These leading labs might not ever be profitable, but their products are doing a lot of good in the world. You may or may not be a user of or believer in their technology, but their staggering, ongoing usage growth suggests that an awful lot of people would be disappointed if the companies simply disappeared.

The problem isn’t the people or the products, it’s the system. As constituted, OpenAI and Anthropic may not be valuable as market equities. If the market assesses they are not capable of producing a growing financial return on investment for shareholders, the companies will collapse.

Maybe private, for-profit is just not the right economic model under which to develop AI. Perhaps OpenAI should be returned to its private non-profit roots, the legacy they fought so hard to change and which Anthropic’s founders spurned. Or possibly both could be reorganized as research centers at universities, returning to academia the scores of high-profile research faculty they have poached.

But a better outcome for society would be to establish public ownership and operation of their product-oriented capabilities. Turn OpenAI and Anthropic into US government agencies producing AI as a public good.

Transitioning the big AI labs into public agencies would require some restructuring. We can separate these companies into two pieces: product innovation and compute operations. The innovation function can be publicly managed, akin to national labs. Congress could provide more rigorous oversight than the kind of unfettered venture capital these labs have recently had access to. The US has a long, successful history of these kinds of institutions, which have produced world-shaping innovations in spaceflight, telecommunications, nuclear power and more. Congress currently manages a $200bn R&D portfolio, within which frontier AI development is, arguably, a glaring gap.

AI operations could be managed as a commodity resource, like public electrical or water utilities: local or regional ownership, nationwide distribution and strict regulation on how they balance fee extraction from ratepayers with raising capital for infrastructure investment. Although AI datacenters are not the same as power or water treatment plants, the US also has a long history of managing national, regional and state supercomputing centers.

Other countries, including Switzerland, Spain and Singapore, are already operating public AI labs. They also have national supercomputing centers already providing public access for running AI models for general use, as do Germany and Australia.

The benefits to the public are clear. Through democratic oversight, the most important AI models could become open, transparent and responsive to the demands of the public rather than private shareholders. They could be aligned to democratic values rather than corporate profits, never taking advertiser money to promote certain brands and training on only appropriately licensed data. And they could be set to focus on the realistic and pro-social goal of maximizing the usefulness of AI to society rather than the fanciful and anti-social goal of supplanting humans with artificial general intelligence.

By emphasizing scientific cooperation rather than corporate competition, we could also reduce the overall resource and environmental cost associated with AI. Instead of perpetually dueling training runs of each companies’ models at ever large scales targeted to fuel investor hype, we could limit AI training resources based on cost and benefit to the public.

What’s in it for the companies themselves and their employees, who sacrifice hypothetical billions in equity by ceding to public ownership? A return to their roots and to their core mission of developing AI safely in the public interest, if they are serious about it. Both companies are theoretically bound through their governance structures to prioritize mission over profit anyway (not that anyone really thinks that’s how they currently operate).

To be clear, we’re not advocating for a golden parachute for the executives or investors, or for continuing the outlandish pay rates of the most highly remunerated AI researchers. If the public is footing the bill, these compensation packages should be aligned to the civil service and those employees not satisfied with that can go elsewhere—if the business models of any remaining private labs still support much higher pay.

While we believe that these companies are unsustainable as private firms, the timeline remains unclear. Their primary investor story is that AI is a race to “artificial general intelligence”—the kind of AI you’re used to from science fiction. The bet seems to be that the two companies can convince enough people that this outcome will turn them a profit, go public, and then make their investors and employees rich before the bubble bursts.

But suppose that the bubble bursts. If the US is smart, it will catch the companies as they fall. Regardless of what the markets think, to the public, they’re too valuable to let die.

There are plenty of stories about inventors who see a problem and decide they can do better. But Van Phillips had a little more motivation than most. The problem was his own leg. In 1976, Phillips was a 21-year-old college student when a water-skiing accident cost him his left leg below the knee. If that wasn’t bad enough, the prosthetic leg he received afterward wasn’t exactly a technological marvel. Prosthetic limbs of the era were generally designed to look and act something like a biological leg and foot, but “act” might be giving them too much credit. They were passive structures that provided something to stand on and roll over while walking.

Phillips wanted to do more than walk. There was just one problem: he wasn’t an engineer. Before the accident, he had been studying business. So, if he was going to build a better leg, first he was going to have to learn how.

Back To School

Phillips became fascinated with prosthetics and eventually studied prosthetic design at Northwestern University’s Prosthetic-Orthotic Center. He also worked at the University of Utah’s prosthetics laboratory, where he had access to both the people and equipment he needed to experiment.

The conventional wisdom was that a prosthetic foot should imitate a human foot. That seems perfectly reasonable — evolution has had quite a long time to work on the design. But there’s a problem with simply copying the shape. A real foot isn’t just a foot-shaped object attached to the bottom of your leg. Muscles, tendons, and ligaments store and release energy as you walk or run. Your Achilles tendon, in particular, acts very much like a spring. A conventional prosthetic foot might look right, but it didn’t have anything corresponding to that spring.

Phillips eventually stopped worrying so much about making something that looked like a foot. Instead, he decided to make something that worked like one.

Spring In Your Step

The basic idea behind what became the Flex-Foot is simple, but unobvious: use a spring as the foot. As is often the case, the concept is the easy part. Making a spring that will repeatedly support the weight of a human being, flex the right amount, survive millions of cycles, fit into a practical prosthesis, and not occasionally snap and dump its owner onto the pavement is considerably harder. The answer was carbon-fiber composite.

Today, carbon fiber turns up everywhere from airplanes to bicycles to suspiciously expensive automotive trim. In the late 1970s and early 1980s, though, it was still an exotic material, and the design problem was genuinely nasty. A prosthetic foot spends every waking hour of its owner’s life under cyclic load — tens of thousands of flex cycles a week, millions over a product’s lifetime — with a full body weight snapping through it on every step and several times that on every stride of a run. Get the fiber layup or resin choice wrong, and you don’t get a gentle failure; you get delamination or a sudden snap, with the wearer still attached. Tuning it added another layer: the same blade has to feel right for wildly different body weights and gait styles, which meant iterating on the curvature, the laminate thickness, and where along the blade the flex was concentrated, rather than just picking “carbon fiber” off a shelf and calling it done. Phillips wasn’t merely drawing this stuff on paper, either — he tested prototypes on himself, and by his own accounts the early ones failed more than once before the layup and geometry held up to real use.

Instead of a rigid ankle and artificial foot, the Flex-Foot used a curved composite member extending down the leg and underneath it. When the wearer put weight on the prosthesis, the carbon-fiber structure flexed and stored energy. As the wearer moved forward and unloaded it, the spring returned some of that energy — much closer to what the biological machinery in your lower leg actually does.

Form Follows Function

Phillips founded Flex-Foot, Inc. in 1984, and the design evolved into a family of prosthetic feet. One particularly interesting development was that once you abandon the requirement that a prosthetic foot has to look like a foot, you have quite a bit of design freedom. That’s where the familiar running blade comes from.

The later Cheetah running foot, made by the Icelandic company Össur after it acquired Flex-Foot, takes the idea to its logical conclusion. There’s hardly any pretense that it is an artificial human foot. It is a long, curved carbon-fiber spring, generally shaped something like a J. Load it and it bends. Release the load, and it springs back. If you’ve watched the Paralympics, you’ve almost certainly seen them.

There is something particularly satisfying about the design from an engineering standpoint. Your first instinct is to mimic the original device — in this case, a human foot and leg. Phillips, instead, identified what the system actually needed to do. That’s a lesson that applies well outside prosthetics. Nature’s solution isn’t necessarily the only solution, and copying the appearance of a biological system doesn’t necessarily reproduce its behavior. Airplanes don’t flap their wings, either.

Too Good?

Of course, once prosthetic legs became good enough to let amputees run competitively, an odd question arose: could they become too good? That became a formal legal dispute in 2007–2008, when the IAAF (now World Athletics) moved to bar South African sprinter Oscar Pistorius, a double amputee running on Össur’s Cheetah Flex-Foot blades, from competing against able-bodied athletes.

The IAAF’s case leaned heavily on research from German sports scientist Gert-Peter Brüggemann, who argued the blades were mechanically efficient enough to constitute an unfair aid under the federation’s own rule against springs, wheels, or other advantage-granting devices. Pistorius’s side countered with independent testing led by MIT biomechanics researcher Hugh Herr, arguing there was no measurable edge. When the case reached the Court of Arbitration for Sport in 2008, the panel sided with Pistorius: it found the IAAF had not shown sufficient evidence of a metabolic advantage from using the Cheetah Flex-Foot, and overturned the ban.

That ruling didn’t settle the underlying biomechanics so much as expose how messy the question really is. Running blades are light and return a meaningful share of stored elastic energy, but they aren’t motors — they can’t give back energy that wasn’t put into them, and they lack the active muscle contribution a biological leg supplies, particularly out of the blocks and around a curve. Depending on which variable you isolate — limb mass, ground-contact time, force production, or acceleration mechanics — the prosthesis can look like an advantage or a disadvantage. It’s a genuinely open biomechanics problem dressed up as a sports-eligibility ruling.

The controversy eventually became as much a question about what constitutes a “normal” human body as it was an engineering problem. That’s a pretty remarkable problem for an invention to have. In a few decades, the question had gone from “can we make an amputee walk better?” to “is this prosthetic leg unfair to people who still have legs?”

Better Than A Fake Foot

Flex-Foot was acquired by Össur in 2000. Phillips received the Lemelson-MIT Prize in 1997 and was inducted into the National Inventors Hall of Fame in 2008 — the same year the CAS ruling put his design at the center of a sports-eligibility debate. Descendants of his original design are still in use today: energy-storing-and-returning feet are now an ordinary part of modern prosthetics, and specialized running blades have become almost synonymous with amputee athletics.

Even if you never design a prosthetic, the lesson is a valuable one. When solving a problem, it is natural to mimic something that already exists, either natural or an earlier design. But real innovation often comes when you stand back and consider what you actually need. Not every hole has to be made with a drill.

If you aren’t big on springs, you could 3D print a foot. We think it is cool to be able to create your own prosthetics.

Here’s a seemingly simple question: given a chunk of multi-line text, how do you split it and return an array whose members are the constituent lines of the text?

Hopefully, your first instinct is to reach for some sort of standard-library function, maybe something like the splitlines() method of Python’s str type. Because it turns out this “simple” question is actually pretty complex to answer! For example, quite some time ago I read a post by William Woodruff pointing out the surprising discovery that Python treats up to eleven different Unicode code points or code point sequences as indicating a line break.

At the time I meant to write about that, but a lot of other things started fighting for my time, and it’s only now that I’m finally digging it out of my drafts. Still, better late than never, so today let’s dig into some of the many ways there are to break a line of text and how they’ve been standardized and specified and ultimately wound up in the set Python uses.

In the beginning…

Once upon a time, there was ASCII. Of course there were other things before ASCII, and alongside ASCII, but for today’s discussion we really only need to go back to ASCII; if you want the full history of physical teletypes, how they evolved from typewriters and influenced character sets for computing and so on, I suggest Wikipedia. Here, I’m just going to gloss over and simplify a lot of that to focus on the topic at hand.

So. Once upon a time, there was ASCII. And it wound up being incredibly influential and important in computing, to an extent other early character sets couldn’t match. And because it was used on computers which used teletypes (basically electronic typewriters connected as input/output devices) as a user interface, it contained control characters for sending commands to the teletype. Such as a LINE FEED (byte value 0x0A) to advance the paper vertically to the next line, and a CARRIAGE RETURN (byte value 0x0D) to re-align the print head/carriage with the horizontal start point of the line.

These are often abbreviated LF and CR (or by their C-family escape sequences \n and \r, respectively), and you might think that since physically advancing a typewriter-style device to be ready to print the next line requires both operations, that would have just become the universal way everybody did new lines. Or at least the universal way everybody did them in English, or in the US, where ASCII dominated. Right?

Well, nothing is ever that simple. Physical teletypes apparently benefited from the two-character approach (as opposed to a single “new line” character) because it gave them time to physically move everything into the right position. But as virtual teletypes—“printing” to a television-like display instead of to paper—became more common, that was less of an issue. So there were multiple possible options for representing line breaks, and several of them showed up in historical systems. For example:

• CP/M used CR LF. And so MS-DOS, which aimed for compatibility with it, used CR LF too. And so Microsoft Windows, which wanted to be compatible with MS-DOS, also used it.
• Meanwhile, Multics chose to use just LF with no CR, and Unix went along with that choice.
• But Commodore and Apple and many others went yet another way and used plain CR , with no LF.

This meant “plain text” was not easily portable between these various systems, since none of them could agree on how to represent a line break. Which led to one of my all-time favorite programming jokes, in the infamous “NOT the comp.text.sgml FAQ” document:

Q. What’s an RE?

A. RE is an acronym for Record End, which is sort of like a newline, only different. Goldfarb’s First Law of Text Processing states that:

“… if a text processing system has bugs, at least one of them will have to do with the handling of input line endings.”

[The Handbook, footnote p. 321]

The Record End concept was introduced to make sure that SGML parsers don’t violate Goldfarb’s First Law.

(for the uninitiated, Charles Goldfarb created SGML)

Anyway, over twenty years ago Python tried (in Python 2.3) to smooth this over by introducing “universal newline” mode for opening files, which accepts all three options: a plain \n (Unix), or a plain \r (classic Mac), or an \r\n sequence (DOS and Windows) will all be interpreted as line breaks.

But even in ASCII there there are other ways of breaking a line. For example, at byte value 0x0C ASCII includes the FORM FEED control character (FF, or \f). Which is not one of the traditional characters used by major operating systems as a “newline”, but nonetheless does cause a new line to occur: it moves to the next page (if necessary, by ejecting the current sheet of paper from the printer and feeding in a new one). And there’s also 0x0B, VERTICAL TAB (VT or \v): just as a “regular” tab (\t) causes a horizontal adjustment, a vertical tab causes a vertical one. So it, too, causes output to advance to another line (probably skipping several in the process).

And the C1 control characters added 0x85, the NEXT LINE character (typically abbreviated NEL), useful for translating back and forth between ASCII and IBM’s EBCDIC character set (which had “New Line” as a single character).

Then Unicode happened

Today we live in a Unicode world, and Unicode tries its hardest to catalog and standardize and describe how to work with all the world’s writing systems. Chapter 5, Section 8 of the Unicode Standard, “Newline Guidelines”, lists seven code points to recognize as causing new lines. Five of them we’ve seen already:

• U+000A LINE FEED, from ASCII
• U+000B LINE TABULATION, from ASCII’s vertical tab
• U+000C FORM FEED, from ASCII
• U+000D CARRIAGE RETURN, from ASCII
• U+0085 NEXT LINE, from the C1 control codes

The CR LF sequence is also recognized, on systems which use it.

But the other two code points are new and were created specifically for Unicode:

• U+2028 LINE SEPARATOR (which Unicode likes to abbreviate as LS)
• U+2029 PARAGRAPH SEPARATOR (similarly abbreviated as PS)

The Unicode Standard explains that the traditional newline characters had started to become ambiguous, because of the rise of tools such as word-processing programs which automatically wrapped lines for display and so began using explicit “newline” characters to mean a paragraph break rather than a line break. So Unicode added two new code points whose purposes are explicit. And the standard says that “[I]n Unicode text, the PS and LS characters should be used wherever the desired function is unambiguous.”

This set of line-breaking code points originated in version 5.0 of Unicode, with Unicode Technical Report #13, which lists the seven “newline” code points and the CR LF sequence. This is also the set of code points and sequences defined for line boundaries in Unicode regular expressions, Unicode Technical Standard #18.

And expanding on Chapter 5 of the Standard, there’s Unicode Standard Annex #14, “Unicode Line Breaking Algorithm”. As the name implies, this document formally specifies the line-breaking algorithm for Unicode, including defining things like which characters offer an opportunity to break a line, whether the break is mandatory, and whether the break would come before or after the character in question. It does this in a typical Unicode way: by defining a set of named properties and specifying which characters have which properties.

Two ways about it

But there are still three “newline” characters supported by Python that we haven’t seen yet, and they come from a place that might be surprising: Unicode Standard Annex #9, the bidirectional algorithm. And it’s OK if you’re wondering what that has to do with newlines, because it’s not immediately obvious if you don’t already know about it.

Some written scripts, like the Latin script this blog post is written in, are written and read left-to-right: the start of a line of text is on the left-hand side, and the end is on the right-hand side. Other scripts, such as Arabic or Hebrew, do the opposite, and are right-to-left. And so Unicode, which again wants to cover all the world’s writing systems and let you use any or all of them, has to support both left-to-right and right-to-left horizontal text direction.

But more than that, it has to support switching direction within a single piece of text. You might have something that’s in, say, Arabic but quotes something in Spanish in the middle of a line; that would require a short section of left-to-right inside an otherwise right-to-left text. Or you might be writing something that uses boustrophedon, switching directions on each line. So Unicode includes direction-control characters like U+200E LEFT-TO-RIGHT MARK and U+200F RIGHT-TO-LEFT MARK to handle this. But it also needs to know the scope of a direction change, and that’s where the last “newline” characters come in: the Unicode bidirectional algorithm says that “[t]he effects of all of these formatting characters are limited to the current paragraph; thus, they are terminated by a paragraph separator”.

So Unicode characters have, among their properties, a “bidirectional class” which influences how they affect the bidirectional algorithm. And the characters which act as paragraph separators for purposes of ending the effects of an explicit directional marker all share a common value for this: bidirectional class B. The characters with that class include quite a few that we’ve already seen, along with three more characters:

• U+001C INFORMATION SEPARATOR FOUR
• U+001D INFORMATION SEPARATOR THREE
• U+001E INFORMATION SEPARATOR TWO

But these are better known by their original ASCII names: FILE SEPARATOR, GROUP SEPARATOR, and RECORD SEPARATOR. ASCII provided these to help represent data structures in memory and on storage media. Today it’s not as common to try to use control characters for this purpose, though they do have the virtue of being rare in actual text, unlike other common delimiters such as tab or comma.

End of the line

And now, after looking at multiple character sets and five Unicode technical documents, we can finally state clearly what’s going on in Python.

Python’s splitlines() treats ten different code points, and one multi-code-point sequence, as causing a line break. These are:

• The sequence U+000D U+000A (CR LF).
• The four code points which have line-breaking property BK (Mandatory Break (Non-tailorable)): U+000B LINE TABULATION , U+000C FORM FEED, U+2028 LINE SEPARATOR, and U+2029 PARAGRAPH SEPARATOR.
• The one code point which has line-breaking property CR (Carriage Return (Non-tailorable)): U+000D CARRIAGE RETURN.
• The one code point which has line-breaking property LF (Line Feed (Non-tailorable)): U+000A LINE FEED.
• The one code point which has line-breaking property NL (Next Line (Non-tailorable)): U+0085 NEXT LINE.
• The three code points which don’t have any of the above line-breaking properties, but do have bidirectional property B: U+001C INFORMATION SEPARATOR FOUR, U+001D INFORMATION SEPARATOR THREE, and U+001E INFORMATION SEPARATOR TWO

Which is also exactly what’s stated by a comment in the CPython source code accompanying the list of individual code points that are considered to break lines, but hopefully now you have a better understanding of what that comment means and how this particular set was arrived at.

Avian Visitors is a lovely project by [Teddy Warner] that uses a Raspberry Pi and microphone to keep track of which birds have been visiting your home, and creates a colorful illustration of recent visitors on top of it all.

It reports on a web interface of its own making, but what really takes things to a new level is an optional, stylish E-Ink panel that shows the last 24 hours’ worth of visitors at a glance in a collage.

The key to identification is BirdNET (GitHub here), a deep learning classifier from Cornell that can reliably identify and classify more than 11,000 species worldwide based on sound alone.

Based on that information, the system pulls bird images from a reference set for the region and creates a collage representing the breadth and frequency of visitors in a single image. The larger the image of a bird, the more frequently it was heard.

That’s a cool project, but [Teddy] took things one step further by setting up a color E-Ink display to show a running summary of all the avian visitors the system identifies. [Teddy] has a knack for leveraging projects into wall-mounted art, as we saw with his generative art wall plotter.

Got ideas of your own? Avian Visitors even has options for sending the latest detection to Home Assistant or over MQTT, allowing automation triggers based on specific bird species. If you decide to try it out and put your own spin on it, be sure to let us know by sending us a tip!

The GitHub repository for Avian Visitors has everything you need to get set up, and the basic system needs little more than a Raspberry Pi and a USB microphone. There’s a build video embedded just below, so give it a shot if you want to get a better idea of what birds come visiting.

Click here to go see the bonus panel!

Hovertext:
The weird part is that they're in a Burger King.

Today's News: