I’ve been ob­sessed with pro­ce­dural maps since I was a kid rolling dice on the ran­dom dun­geon ta­bles in the AD&D Dungeon Master’s Guide. There was some­thing mag­i­cal about it — you did­n’t de­sign the dun­geon, you dis­cov­ered it, one room at a time, and the dice de­cided whether you got a trea­sure cham­ber or a dead end full of rats.

Years later, I de­cided to build my own map gen­er­a­tor. It cre­ates lit­tle me­dieval is­land worlds — with roads, rivers, coast­lines, cliffs, forests, and vil­lages — en­tirely pro­ce­du­rally. Built with Three.js WebGPU and TSL shaders, about 4,100 hex cells across 19 grids, gen­er­ated in ~20 sec­onds.

If you’ve ever played Carcassonne, you al­ready un­der­stand WFC. You have a stack of tiles and place them so every­thing lines up. Each tile has edges — grass, road, city. Adjacent tiles must have match­ing edges. A road edge must con­nect to an­other road edge. Grass must meet grass. The only dif­fer­ence is that the com­puter does it faster, and com­plains less when it gets stuck.

The twist: hex tiles have 6 edges in­stead of 4. That’s 50% more con­straints per tile, and the com­bi­na­to­r­ial ex­plo­sion is real. Square WFC is well-trod­den ter­ri­tory. Hex WFC is… less so.

WFC is re­li­able for small grids. But as the grid gets big­ger, the chance of paint­ing your­self into a dead end goes up fast. A 217-cell hex grid al­most never fails. A 4123-cell grid fails reg­u­larly.

The so­lu­tion: mod­u­lar WFC. Instead of one gi­ant solve, the map is split into 19 hexag­o­nal grids arranged in two rings around a cen­ter — about 4,100 cells to­tal. Each grid is solved in­de­pen­dently, but it has to match what­ever tiles were al­ready placed in neigh­bor­ing grids. Those bor­der tiles be­come fixed con­straints.

And some­times those con­straints are sim­ply in­com­pat­i­ble. No amount of back­track­ing in­side the cur­rent grid can fix a prob­lem that was baked in by a neigh­bor. This is where I spent a lot of dev time.

Here’s the dirty se­cret of WFC: it fails. A lot. You make a se­ries of ran­dom choices, prop­a­gate con­straints, and even­tu­ally back your­self into a cor­ner where some cell has zero valid op­tions left. Congratulations, the puz­zle is un­solv­able.

The text­book so­lu­tion is back­track­ing — undo your last de­ci­sion and try a dif­fer­ent tile. My solver tracks every pos­si­bil­ity it re­moves dur­ing prop­a­ga­tion (a “trail” of deltas), so it can rewind cheaply with­out copy­ing the en­tire grid state. It’ll try up to 500 back­tracks be­fore giv­ing up.

But back­track­ing alone is­n’t enough. The real prob­lem is cross-grid bound­aries.

After many failed ap­proaches, I landed on a lay­ered re­cov­ery sys­tem:

Layer 1: Unfixing. During the ini­tial con­straint prop­a­ga­tion, if a neigh­bor cell cre­ates a con­tra­dic­tion, the solver con­verts it from a fixed con­straint back into a solv­able cell. Its own neigh­bors (two cells out — “anchors”) be­come the new con­straints. This is cheap and han­dles easy cases.

Layer 2: Local-WFC. If the main solve fails, the solver runs a mini-WFC on a small ra­dius-2 re­gion around the prob­lem area — re-solv­ing 19 cells in the over­lap area to cre­ate a more com­pat­i­ble bound­ary. Up to 5 at­tempts, each tar­get­ing a dif­fer­ent prob­lem cell. Local-WFC was the break­through. Instead of try­ing to solve the im­pos­si­ble, go back and change the prob­lem.

Layer 3: Drop and hide. Last re­sort. Drop the of­fend­ing neigh­bor cell en­tirely and place moun­tain tiles to cover the seams. Mountains are great — their cliff edges match any­thing, and they look in­ten­tional. Nobody ques­tions a moun­tain.

This map is­n’t flat — it has 5 lev­els of el­e­va­tion. Ocean and Grass start at level 0, but slopes and cliffs can move up or down a level. Low slopes go up 1 level, high slopes go up 2 lev­els. A road tile at level 3 needs to con­nect to an­other road tile at level 3, or a slope tile that tran­si­tions be­tween lev­els. Get it wrong and you end up with roads that dead-end into cliff faces or rivers flow­ing up­hill into the sky. The el­e­va­tion axis turns a 2D con­straint prob­lem into a 3D one, and it’s where a lot of the tile va­ri­ety (and a lot of the solver fail­ures) comes from.

The bet­ter ap­proach: cube co­or­di­nates (q, r, s where s = -q-r). It’s a 3D co­or­di­nate sys­tem for the three hex axes. Neighbor find­ing be­comes triv­ial — just add or sub­tract 1 from two co­or­di­nates.

The good news is that WFC does­n’t re­ally care about geom­e­try. It’s con­cerned with which edges match which — it’s es­sen­tially a graph prob­lem. The hex co­or­di­nates only mat­ter for ren­der­ing and for the multi-grid lay­out, where the 19 grids are them­selves arranged as a hex-of-hexes with their own off­set po­si­tions.

If you’ve ever worked with hex grids, you owe Amit Patel at Red Blob Games a debt of grat­i­tude. His hex grid guide is the de­fin­i­tive ref­er­ence.

Trees, Buildings, and Why Not Everything Should Be WFC

Early on, I tried us­ing WFC for tree and build­ing place­ment. Bad idea. WFC is great at lo­cal edge match­ing but ter­ri­ble at large-scale pat­terns. You’d get trees scat­tered ran­domly in­stead of clus­tered into forests, or build­ings spread evenly in­stead of gath­ered into vil­lages.

The so­lu­tion: good old Perlin noise. A global noise field de­ter­mines tree den­sity and build­ing place­ment, com­pletely sep­a­rate from WFC. Areas where the noise is above a thresh­old get trees; slightly dif­fer­ent noise dri­ves build­ings. This gives you or­ganic clus­ter­ing — forests, clear­ings, vil­lages — that WFC could never pro­duce. I also used some ad­di­tional logic to place build­ings at the end of roads, ports and wind­mills on coasts, henges on hill­tops etc.

WFC han­dles the ter­rain. Noise han­dles the dec­o­ra­tions. Each tool does what it’s good at.

I wanted that ‘Zelda: The Wind Waker’ car­toon shim­mer on the wa­ter sur­face. Originally I tried gen­er­at­ing caus­tics pro­ce­du­rally with four lay­ers of Voronoi noise. This turned out to be very GPU heavy and did not look great. The so­lu­tion was sam­pling a small scrolling caus­tic tex­ture with a sim­ple noise mask, which looks way bet­ter and is su­per cheap. Sometimes the easy so­lu­tion is the cor­rect so­lu­tion.

Waves are sine bands that ra­di­ate out­ward from coast­lines, in­spired by Bad North’s gor­geous shore­line ef­fect. To know “how far from the coast” each pixel is, the sys­tem ren­ders a coast mask — a top down or­tho­graphic ren­der of the en­tire map with white for land and black for wa­ter — then di­lates and blurs it into a gra­di­ent. The wave shader reads this gra­di­ent to place an­i­mated sine bands at reg­u­lar dis­tance in­ter­vals, with noise to break up the pat­tern.

This worked great on straight coast­lines. In con­cave coves and in­lets, the wave lines got thick and ugly. The blur-based gra­di­ent spreads the same value range over a wider phys­i­cal area in coves, stretch­ing the wave bands out.

Screen-space de­riv­a­tives to de­tect gra­di­ent stretch­ing — worked at one zoom level, broke at oth­ers.

Texture-space gra­di­ent mag­ni­tude to de­tect op­pos­ing coast edges can­cel­ing out — only de­tected nar­row rivers, not ac­tual prob­lem coves.

The fun­da­men­tal is­sue: blur en­codes “how much land is nearby,” not “how far is the near­est coast edge.” These are dif­fer­ent ques­tions, and no amount of post-pro­cess­ing the blur can ex­tract true dis­tance.

The solve was to do a CPU-side “surroundedness” probe that checks each wa­ter cel­l’s neigh­bors to de­tect coves, writ­ing a sep­a­rate mask tex­ture that thins the waves in en­closed ar­eas. It’s kind of a hack but it works and the wave edges thin out nicely at the edges.

No dice re­quired this time — but the feel­ing is the same. You hit a but­ton, the map builds it­self, and you dis­cover what the al­go­rithm de­cided to put there. It’s su­per sat­is­fy­ing to see the road and river sys­tems match­ing up per­fectly. Every time it’s dif­fer­ent, and every time I find my­self ex­plor­ing for a while. The kid rolling dice on the dun­geon ta­bles would be into this.

Last week, Dan Blanchard, the main­tainer of chardet—a Python li­brary for de­tect­ing text en­cod­ings used by roughly 130 mil­lion pro­jects a month—re­leased a new ver­sion. Version 7.0 is 48 times faster than its pre­de­ces­sor, sup­ports mul­ti­ple cores, and was re­designed from the ground up. Anthropic’s Claude is listed as a con­trib­u­tor. The li­cense changed from LGPL to MIT.

Blanchard’s ac­count is that he never looked at the ex­ist­ing source code di­rectly. He fed only the API and the test suite to Claude and asked it to reim­ple­ment the li­brary from scratch. The re­sult­ing code shares less than 1.3% sim­i­lar­ity with any prior ver­sion, as mea­sured by JPlag. His con­clu­sion: this is an in­de­pen­dent new work, and he is un­der no oblig­a­tion to carry for­ward the LGPL. Mark Pilgrim, the li­brary’s orig­i­nal au­thor,

opened a GitHub is­sue to ob­ject. The LGPL re­quires that mod­i­fi­ca­tions be dis­trib­uted un­der the same li­cense, and a reim­ple­men­ta­tion pro­duced with am­ple ex­po­sure to the orig­i­nal code­base can­not, in Pilgrim’s view, pass as a clean-room ef­fort.

The dis­pute drew re­sponses from two promi­nent fig­ures in the open source world. Armin Ronacher, the cre­ator of Flask, wel­comed the re­li­cens­ing. Salvatore Sanfilippo (antirez), the cre­ator of Redis,

pub­lished a broader de­fense of AI reim­ple­men­ta­tion, ground­ing it in copy­right law and the his­tory of the GNU pro­ject. Both con­clude, by dif­fer­ent routes, that what Blanchard did is le­git­i­mate. I re­spect both writ­ers, and I think both are wrong—or more pre­cisely, both are evad­ing the ques­tion that ac­tu­ally mat­ters.

That ques­tion is this: does le­gal mean le­git­i­mate? Neither piece an­swers it. Both move from “this is legally per­mis­si­ble” to “this is there­fore fine,” with­out paus­ing at the gap be­tween those two claims. Law sets a floor; clear­ing it does not mean the con­duct is right. That gap is where this es­say be­gins.

Antirez builds his case on his­tory. When the GNU pro­ject reim­ple­mented the UNIX user­space, it was law­ful. So was Linux. Copyright law pro­hibits copy­ing “protected ex­pres­sions”—the ac­tual code, its struc­ture, its spe­cific mech­a­nisms—but it does not pro­tect ideas or be­hav­ior. AI-assisted reim­ple­men­ta­tion oc­cu­pies the same le­gal ground. Therefore, it is law­ful.

The le­gal analy­sis is largely cor­rect, and I am not dis­put­ing it. The prob­lem lies in what an­ti­rez does next: he pre­sents the le­gal con­clu­sion as if it were also a so­cial one, and uses a his­tor­i­cal anal­ogy that, ex­am­ined more care­fully, ar­gues against his own po­si­tion.

When GNU reim­ple­mented the UNIX user­space, the vec­tor ran from pro­pri­etary to free. Stallman was us­ing the lim­its of copy­right law to turn pro­pri­etary soft­ware into free soft­ware. The eth­i­cal force of that pro­ject did not come from its le­gal per­mis­si­bil­ity—it came from the di­rec­tion it was mov­ing, from the fact that it was ex­pand­ing the com­mons. That is why peo­ple cheered.

The vec­tor in the chardet case runs the other way. Software pro­tected by a copy­left li­cense—one that guar­an­tees users the right to study, mod­ify, and re­dis­trib­ute de­riv­a­tive works un­der the same terms—has been reim­ple­mented un­der a per­mis­sive li­cense that car­ries no such guar­an­tee. This is not a reim­ple­men­ta­tion that ex­pands the com­mons. It is one that re­moves the fenc­ing that pro­tected the com­mons. Derivative works built on chardet 7.0 are un­der no oblig­a­tion to share their source code. That oblig­a­tion, which ap­plied to a li­brary down­loaded 130 mil­lion times a month, is now gone.

Antirez does not ad­dress this di­rec­tional dif­fer­ence. He in­vokes the GNU prece­dent, but that prece­dent is a coun­terex­am­ple to his con­clu­sion, not a sup­port­ing one.

Ronacher’s ar­gu­ment is dif­fer­ent. He dis­closes up­front that he has a stake in the out­come: “I per­son­ally have a horse in the race here be­cause I too wanted chardet to be un­der a non-GPL li­cense for many years. So con­sider me a very bi­ased per­son in that re­gard.” He goes on to write that he con­sid­ers “the GPL to run against that spirit by re­strict­ing what can be done with it”—the spirit be­ing that so­ci­ety is bet­ter off when we share.

This claim rests on a fun­da­men­tal mis­read­ing of what the GPL does.

Start with what the GPL ac­tu­ally pro­hibits. It does not pro­hibit keep­ing source code pri­vate. It im­poses no con­straint on pri­vately mod­i­fy­ing GPL soft­ware and us­ing it your­self. The GPL’s con­di­tions are trig­gered only by dis­tri­b­u­tion. If you dis­trib­ute mod­i­fied code, or of­fer it as a net­worked ser­vice, you must make the source avail­able un­der the same terms. This is not a re­stric­tion on shar­ing. It is a con­di­tion placed on shar­ing: if you share, you must share in kind.

The re­quire­ment that im­prove­ments be re­turned to the com­mons is not a mech­a­nism that sup­presses shar­ing. It is a mech­a­nism that makes shar­ing re­cur­sive and self-re­in­forc­ing. The claim that im­pos­ing con­tri­bu­tion oblig­a­tions on users of a com­mons un­der­mines shar­ing cul­ture does not hold to­gether log­i­cally.

The con­trast with the MIT li­cense clar­i­fies the point. Under MIT, any­one may take code, im­prove it, and close it off into a pro­pri­etary prod­uct. You can re­ceive from the com­mons with­out giv­ing back. If Ronacher calls this struc­ture “more share-friendly,” he is us­ing a con­cept of shar­ing with a spe­cific di­rec­tion­al­ity built in: shar­ing flows to­ward who­ever has more cap­i­tal and more en­gi­neers to take ad­van­tage of it.

The his­tor­i­cal record bears this out. In the 1990s, com­pa­nies rou­tinely ab­sorbed GPL code into pro­pri­etary prod­ucts—not be­cause they had cho­sen per­mis­sive li­censes, but be­cause copy­left en­force­ment was slack. The strength­en­ing of copy­left mech­a­nisms closed that gap. For in­di­vid­ual de­vel­op­ers and small pro­jects with­out the re­sources to com­pete on any­thing but rec­i­proc­ity, copy­left was what made the ex­change ap­prox­i­mately fair.

The cre­ator of Flask knows this dis­tinc­tion. If he elides it any­way, the ar­gu­ment is not naïve—it is con­ve­nient.

The most in­ter­est­ing mo­ment in Ronacher’s piece is not the ar­gu­ment but a de­tail he men­tions in pass­ing: Vercel reim­ple­mented GNU Bash us­ing AI and pub­lished it, then got vis­i­bly up­set when Cloudflare

reim­ple­mented Next.js the same way.

Ronacher notes this as an irony and moves on. But the irony cuts deeper than he lets on. Next.js is MIT li­censed. Cloudflare’s vinext did not vi­o­late any li­cense—it did ex­actly what Ronacher calls a con­tri­bu­tion to the cul­ture of open­ness, ap­plied to a per­mis­sively li­censed code­base. Vercel’s re­ac­tion had noth­ing to do with li­cense in­fringe­ment; it was purely com­pet­i­tive and ter­ri­to­r­ial. The im­plicit po­si­tion is: reim­ple­ment­ing GPL soft­ware as MIT is a vic­tory for shar­ing, but hav­ing our own MIT soft­ware reim­ple­mented by a com­peti­tor is cause for out­rage. This is what the claim that per­mis­sive li­cens­ing is “more share-friendly” than copy­left looks like in prac­tice. The spirit of shar­ing, it turns out, runs in one di­rec­tion only: out­ward from one­self.

Ronacher reg­is­ters the con­tra­dic­tion and does not stop. “This de­vel­op­ment plays into my world­view,” he writes. When you pre­sent ev­i­dence that cuts against your own po­si­tion, ac­knowl­edge it, and then pro­ceed to your orig­i­nal con­clu­sion un­changed, that is a sig­nal that the con­clu­sion pre­ceded the ar­gu­ment.

Back to the ques­tion posed at the start. Is le­gal the same as le­git­i­mate?

Antirez closes his care­ful le­gal analy­sis as though it set­tles the mat­ter. Ronacher ac­knowl­edges that “there is an ob­vi­ous moral ques­tion here, but that is­n’t nec­es­sar­ily what I’m in­ter­ested in.” Both pieces treat le­gal per­mis­si­bil­ity as a proxy for so­cial le­git­i­macy. But law only says what con­duct it will not pre­vent—it does not cer­tify that con­duct as right. Aggressive tax min­i­miza­tion that never crosses into il­le­gal­ity may still be widely re­garded as an­ti­so­cial. A phar­ma­ceu­ti­cal com­pany that legally ac­quires a patent on a long-generic drug and raises the price a hun­dred­fold has not done some­thing le­gal and there­fore fine. Legality is a nec­es­sary con­di­tion; it is not a suf­fi­cient one.

In the chardet case, the dis­tinc­tion is sharper still. What the LGPL pro­tected was not Blanchard’s la­bor alone. It was a so­cial com­pact agreed to by every­one who con­tributed to the li­brary over twelve years. The terms of that com­pact were: if you take this and build on it, you share back un­der the same terms. This com­pact op­er­ated as a le­gal in­stru­ment, yes, but it was also the foun­da­tion of trust that made con­tri­bu­tion ra­tio­nal. The fact that a reim­ple­men­ta­tion may qual­ify legally as a new work, and the fact that it breaks faith with the orig­i­nal con­trib­u­tors, are sep­a­rate ques­tions. If a court even­tu­ally rules in Blanchard’s fa­vor, that rul­ing will tell us what the law per­mits. It will not tell us that the act was right.

Zoë Kooyman, ex­ec­u­tive di­rec­tor of the FSF, put it plainly: “Refusing to grant oth­ers the rights you your­self re­ceived as a user is highly an­ti­so­cial, no mat­ter what method you use.”

Reading this de­bate, I keep re­turn­ing to a ques­tion about po­si­tion. From where are these two writ­ers look­ing at the sit­u­a­tion?

Antirez cre­ated Redis. Ronacher cre­ated Flask. Both are fig­ures at the cen­ter of the open source ecosys­tem, with large au­di­ences and well-es­tab­lished rep­u­ta­tions. For them, falling costs of AI reim­ple­men­ta­tion means some­thing spe­cific: it is eas­ier to reim­ple­ment things they want in a dif­fer­ent form. Ronacher says ex­plic­itly that he had be­gun reim­ple­ment­ing GNU Readline pre­cisely be­cause of its copy­left terms.

For the peo­ple who have spent years con­tribut­ing to a li­brary like chardet, the same shift in costs means some­thing else en­tirely: the copy­left pro­tec­tion around their con­tri­bu­tions can be re­moved. The two writ­ers are speak­ing from the for­mer po­si­tion to peo­ple in the lat­ter, telling them that this was al­ways law­ful, that his­tor­i­cal prece­dent sup­ports it, and that the ap­pro­pri­ate re­sponse is adap­ta­tion.

When po­si­tional asym­me­try of this kind is ig­nored, and the ar­gu­ment is pre­sented as uni­ver­sal analy­sis, what you get is not analy­sis but ra­tio­nal­iza­tion. Both writ­ers ar­rive at con­clu­sions that align pre­cisely with their own in­ter­ests. Readers should hold that fact in mind.

Bruce Perens, who wrote the orig­i­nal Open Source Definition, told : “The en­tire eco­nom­ics of soft­ware de­vel­op­ment are dead, gone, over, ka­put!” He meant it as an alarm. Antirez, from a sim­i­lar as­sess­ment of the sit­u­a­tion, draws the con­clu­sion: adapt. Ronacher says he finds the di­rec­tion ex­cit­ing.

None of the three re­sponses ad­dresses the cen­tral ques­tion. When copy­left be­comes tech­ni­cally eas­ier to cir­cum­vent, does that make it less nec­es­sary, or more?

I think more. What the GPL pro­tected was not the scarcity of code but the free­dom of users. The fact that pro­duc­ing code has be­come cheaper does not make it ac­cept­able to use that code as a ve­hi­cle for erod­ing free­dom. If any­thing, as the fric­tion of reim­ple­men­ta­tion dis­ap­pears, so does the fric­tion of strip­ping copy­left from any­thing left ex­posed. The ero­sion of en­force­ment ca­pac­ity is a le­gal prob­lem. It does not touch the un­der­ly­ing nor­ma­tive judg­ment.

That judg­ment is this: those who take from the com­mons owe some­thing back to the com­mons. The prin­ci­ple does not change de­pend­ing on whether a reim­ple­men­ta­tion takes five years or five days. No court rul­ing on AI-generated code will al­ter its so­cial weight.

This is where law and com­mu­nity norms di­verge. Law is made slowly, af­ter the fact, re­flect­ing ex­ist­ing power arrange­ments. The norms that open source com­mu­ni­ties built over decades did not wait for court ap­proval. People chose the GPL when the law of­fered them no guar­an­tee of its en­force­ment, be­cause it ex­pressed the val­ues of the com­mu­ni­ties they wanted to be­long to. Those val­ues do not ex­pire when the law changes.

In pre­vi­ous writ­ing, I ar­gued for a train­ing copy­left (TGPL) as the next step in this line of de­vel­op­ment. The chardet sit­u­a­tion sug­gests the ar­gu­ment has to go fur­ther: to a spec­i­fi­ca­tion copy­left cov­er­ing the layer be­low source code. If source code can now be gen­er­ated from a spec­i­fi­ca­tion, the spec­i­fi­ca­tion is where the es­sen­tial in­tel­lec­tual con­tent of a GPL pro­ject re­sides. Blanchard’s own claim—that he worked only from the test suite and API with­out read­ing the source—is, para­dox­i­cally, an ar­gu­ment for pro­tect­ing that test suite and API spec­i­fi­ca­tion un­der copy­left terms.

The his­tory of the GPL is the his­tory of li­cens­ing tools evolv­ing in re­sponse to new forms of ex­ploita­tion: GPLv2 to GPLv3, then AGPL. What drove each evo­lu­tion was not a court rul­ing but a com­mu­nity reach­ing a value judg­ment first and then seek­ing le­gal in­stru­ments to ex­press it. The same se­quence is avail­able now. Whatever courts even­tu­ally de­cide about AI reim­ple­men­ta­tion, the ques­tion we need to an­swer first is not a le­gal one. It is a so­cial one. Do those who take from the com­mons owe some­thing back? I think they do. That judg­ment does not re­quire a ver­dict.

What makes the pieces by an­ti­rez and Ronacher worth read­ing is not that they are right. It is that they make vis­i­ble, with un­usual clar­ity, what they are choos­ing not to see. When le­gal­ity is used as a sub­sti­tute for a value judg­ment, the ques­tion that ac­tu­ally mat­ters gets buried in the foot­notes of a law it has al­ready out­grown.

A Broward County judge has dis­missed a red-light cam­era ticket, rul­ing that the state law used to is­sue the ci­ta­tion im­prop­erly shifts the bur­den of proof onto ve­hi­cle own­ers.

In a 21-page or­der signed March 3, Judge Steven P. DeLuca granted a de­fen­dan­t’s mo­tion to dis­miss a photo-en­forced traf­fic ci­ta­tion is­sued un­der Florida’s red-light cam­era law.

The case in­volved a Sunrise red-light cam­era ci­ta­tion is­sued to a reg­is­tered ve­hi­cle owner af­ter au­to­mated cam­eras cap­tured a ve­hi­cle en­ter­ing an in­ter­sec­tion against a red sig­nal. The de­fen­dant ar­gued the statute un­con­sti­tu­tion­ally re­quires the reg­is­tered owner to prove they were not dri­ving — in­stead of re­quir­ing the gov­ern­ment to prove who was be­hind the wheel.

In the or­der, the court found that red-light cam­era cases, al­though la­beled as civil in­frac­tions, func­tion as “quasi-criminal” pro­ceed­ings be­cause they can re­sult in mon­e­tary penal­ties, a for­mal find­ing of guilt, and con­se­quences tied to a dri­ver’s record.

Under Florida Statute 316.0083, once a cam­era cap­tures a vi­o­la­tion, the reg­is­tered owner is pre­sumed re­spon­si­ble un­less they sub­mit an af­fi­davit iden­ti­fy­ing an­other dri­ver. The court ruled that the frame­work im­prop­erly shifts the bur­den of proof away from the state.

Because traf­fic in­frac­tions that move to county court must be proven “beyond a rea­son­able doubt,” the judge wrote that the statute’s pre­sump­tion vi­o­lates con­sti­tu­tional due process pro­tec­tions.

As a re­sult, the ci­ta­tion in this case was for­mally dis­missed.

Click here to view the PDF file

Joel Mumford is an at­tor­ney with The Ticket Clinic. He said if the case is quasi crim­i­nal, which means al­most crim­i­nal or crim­i­nal-like, the state has to fol­low pro­ce­dural due process.

“The state or the agen­cies that is­sue the tick­ets, it’s their bur­den to prove all the el­e­ments of the crime be­yond and to the ex­tent of each and every rea­son­able doubt. And the first el­e­ment, which should be, who’s dri­ving the car,” Mumford said. “The statute in Florida pre­sumes that the reg­is­tered owner is the dri­ver of the car.”

Mumford said even though the court or­der only ap­plies in Broward County, it could open the door for chal­lenges in other parts of the state, mean­ing other coun­ties across the state fol­low­ing suit.

“What could prob­a­bly hap­pen is they the court could then get an ap­peal, and then if it goes up to the dis­trict court of ap­peal level and then make a de­ci­sion on it, de­pend­ing on what that says, that could then be ap­plied to the en­tire state, if there’s no sim­i­lar ap­pel­late cases through­out the state. So that could make it statewide,” he said.

Drivers in Boynton Beach want to see the red-light cam­eras gone.

Fifteen red-light cam­era sys­tems are al­ready run­ning at seven in­ter­sec­tions in Boynton Beach alone. Congress Avenue and Gateway Boulevard is just one of them.

“I’ve been tick­eted here twice, and it’s ridicu­lous be­cause they it’s just not fair,” one dri­ver said who did­n’t want to be iden­ti­fied. The per­son that does the de­ter­mi­na­tion when you ran the light, it’s just a ran­dom. Whoever they want to pick, pick you to say, okay, you’re gonna pay the ticket.”

That dri­ver had to pay his $158 dol­lar ticket but he’s hope­ful Palm Beach County can soon fol­low suit. He wants red light cam­eras gone, so fu­ture vi­o­la­tions could be thrown out.

“I think they need to out­law it and get rid of it,” he said.

Advocacy group StopTheCams, which has long op­posed au­to­mated traf­fic en­force­ment, called the rul­ing a ma­jor vic­tory. In a press re­lease, the group said the de­ci­sion con­firms what crit­ics have ar­gued for years — that red-light cam­era laws pun­ish ve­hi­cle own­ers with­out re­quir­ing proof they com­mit­ted the vi­o­la­tion.

Supporters of red-light cam­eras ar­gue the sys­tems im­prove safety by de­ter­ring dan­ger­ous dri­ving at in­ter­sec­tions. Florida’s red-light cam­era law, known as the Mark Wandall Traffic Safety Act, al­lows lo­cal gov­ern­ments to use au­to­mated en­force­ment sys­tems.

It re­mains un­clear whether the rul­ing will be ap­pealed or how broadly it could af­fect sim­i­lar cases statewide. For now, the de­ci­sion ap­plies to this spe­cific case in Broward County, but le­gal ob­servers say it could fuel re­newed chal­lenges to Florida’s red-light cam­era en­force­ment sys­tem.

Artificial in­tel­li­gence chips are get­ting up­graded more quickly than data cen­ters can be built, a mar­ket re­al­ity that ex­poses a key risk to the AI trade and Oracle’s debt-fu­eled ex­pan­sion.

OpenAI is no longer plan­ning to ex­pand its part­ner­ship with Oracle in Abilene, Texas, home to the Stargate data cen­ter, be­cause it wants clus­ters with newer gen­er­a­tions of Nvidia graph­ics pro­cess­ing units, ac­cord­ing to a per­son fa­mil­iar with the mat­ter.

The cur­rent Abilene site is ex­pected to use Nvidia’s Blackwell proces­sors, and the power is­n’t pro­jected to come on­line for a year. By then, OpenAI is hop­ing to have ex­panded ac­cess to Nvidia’s next-gen­er­a­tion chips in big­ger clus­ters else­where, said the per­son, who asked not to be named due to con­fi­den­tial­ity.

Bloomberg was first to re­port on the com­pa­nies end­ing their plans for ex­pan­sion in Abilene. In a post on X on Sunday, Oracle called news re­ports about the ac­tiv­ity, “false and in­cor­rect,” but the post only said ex­ist­ing pro­jects are on track and did­n’t ad­dress ex­pan­sion plans.

Oracle se­cured the site, or­dered the hard­ware, and spent bil­lions of dol­lars on con­struc­tion and staff, with the ex­pec­ta­tion of go­ing big­ger.

It’s a log­i­cal de­ci­sion for OpenAI, which does­n’t want older chips. Nvidia used to re­lease a new gen­er­a­tion of data cen­ter proces­sors every two years. Now, CEO Jensen Huang has the com­pany ship­ping one every year, and each gen­er­a­tion of­fers a leap in ca­pa­bil­ity. Vera Rubin, un­veiled at CES in January and al­ready in pro­duc­tion, de­liv­ers five times the in­fer­ence per­for­mance of Blackwell.

For the com­pa­nies build­ing fron­tier mod­els, the small­est im­prove­ment in per­for­mance could equate to huge gaps in model bench­marks and rank­ings, which are closely fol­lowed by de­vel­op­ers and trans­late di­rectly to us­age, rev­enue, and val­u­a­tion.

That all points to a big­ger prob­lem at play. For in­fra­struc­ture com­pa­nies, se­cur­ing a site, con­nect­ing power and stand­ing up a fa­cil­ity takes 12 to 24 months at min­i­mum. But cus­tomers want the lat­est and great­est, and they’re track­ing the yearly chip up­grades.

Oracle’s added chal­lenge is that it’s the only hy­per­scaler fund­ing its build­out pri­mar­ily with debt, to the tune of $100 bil­lion and count­ing. Google, Amazon and Microsoft, by con­trast, are lean­ing on their enor­mous cash-gen­er­at­ing busi­nesses.

Meanwhile, Oracle part­ner Blue Owl is de­clin­ing to fund an ad­di­tional fa­cil­ity, and plans to cut up to 30,000 jobs.

Oracle re­ports fis­cal third-quar­ter re­sults on Tuesday, and in­vestors will be pay­ing close to how the com­pany ad­dresses a $50 bil­lion cap­i­tal ex­pen­di­ture plan with neg­a­tive free cash flow, and whether the fi­nanc­ing pipeline can hold up.

The stock is down 23% so far this year and has lost over half its value since peak­ing in September.

Beyond Oracle, GPU de­pre­ci­a­tion is a risk for the broader mar­ket and could have ram­i­fi­ca­tions across the AI land­scape. Every in­fra­struc­ture deal signed to­day may re­sult in a com­mit­ment to out­dated hard­ware be­fore the power is even con­nected.

After sev­eral in­tense and in­cred­i­ble years build­ing Bluesky from the ground up, I’ve de­cided to step back as CEO and tran­si­tion to a new role as Bluesky’s Chief Innovation Officer.

In 2019, I set out to build an open pro­to­col for so­cial me­dia, with the goal of en­abling the de­vel­op­ment of a new gen­er­a­tion of ap­pli­ca­tions de­signed to em­power users. The Bluesky app started off as a ref­er­ence client for the pro­to­col, but has since grown into a thriv­ing plat­form with over 40 mil­lion users. Last year, we grew a world-class team, ex­panded the AT Protocol ecosys­tem, and proved that a val­ues-dri­ven so­cial net­work could thrive at scale.

As Bluesky ma­tures, the com­pany needs a sea­soned op­er­a­tor fo­cused on scal­ing and ex­e­cu­tion, while I re­turn to what I do best: build­ing new things. As part of this tran­si­tion, Toni Schneider, for­mer CEO of Automattic and part­ner at True Ventures, will join our team as in­terim CEO, while our board runs a search for a per­ma­nent chief ex­ec­u­tive.

Toni be­lieves deeply in the Bluesky mis­sion, and has been an ad­vi­sor to the com­pany and me per­son­ally for over a year. Both Automattic and True Ventures are also in­vestors in Bluesky, and sup­port the de­vel­op­ment of a more open, user-dri­ven in­ter­net. Automattic, the com­pany be­hind WordPress.com, has built their busi­ness on open source soft­ware, work­ing to make the web a bet­ter and more par­tic­i­pa­tory place. Toni was a key part of guid­ing that mis­sion, and is some­one who leads with gen­uine cu­rios­ity, takes the long view, and deeply un­der­stands what it means to build a com­pany around a mis­sion. I am con­fi­dent that he is the right per­son to lead us into this next chap­ter.

Scaling up this com­pany has been a learn­ing ex­pe­ri­ence un­like any­thing else. I’ve grown a lot as a leader and had the priv­i­lege of as­sem­bling the best team I’ve ever worked with. As we’ve grown, I’ve found that peo­ple thrive when they’re in a role where their pas­sions over­lap with their strengths. This is as true for me as it is for our team. I’m most en­er­gized by ex­plor­ing new ideas, bring­ing a vi­sion to life, and help­ing peo­ple dis­cover their strengths. Transitioning to a more fo­cused role where I can do what brings me en­ergy is my way of putting that be­lief into prac­tice.

I’m ex­cited to dig into the next fron­tier of what de­cen­tral­ized so­cial can be, while bring­ing Toni in to sup­port our team as an ex­pe­ri­enced op­er­a­tor and leader. The work that got us here was just the be­gin­ning, and I’m grate­ful to keep build­ing along­side this team and com­mu­nity.

My LinkedIn and Twitter feeds are full of screen­shots from the re­cent Forbes ar­ti­cle on Cursor claim­ing that Anthropic’s $200/month Claude Code Max plan can con­sume $5,000 in com­pute. The rel­e­vant quote:

Today, that sub­si­diza­tion ap­pears to be even more ag­gres­sive, with that $200 plan able to con­sume about $5,000 in com­pute, ac­cord­ing to a dif­fer­ent per­son who has seen analy­ses on the com­pa­ny’s com­pute spend pat­terns.

This is be­ing shared as proof that Anthropic is haem­or­rhag­ing money on in­fer­ence. It does­n’t sur­vive ba­sic scrutiny.

I’m fairly con­fi­dent the Forbes sources are con­fus­ing re­tail API prices with ac­tual com­pute costs. These are very dif­fer­ent things.

Anthropic’s cur­rent API pric­ing for Opus 4.6 is $5 per mil­lion in­put to­kens and $25 per mil­lion out­put to­kens. At those prices, yes - a heavy Claude Code Max 20 user could rack up $5,000/month in API-equivalent us­age. That maths checks out.

But API pric­ing is not what it costs Anthropic to serve those to­kens.

The best way to es­ti­mate what in­fer­ence ac­tu­ally costs is to look at what open-weight mod­els of sim­i­lar size are priced at on OpenRouter - where mul­ti­ple providers com­pete on price.

Qwen 3.5 397B-A17B is a good com­par­i­son point. It’s a large MoE model, broadly com­pa­ra­ble in ar­chi­tec­ture size to what Opus 4.6 is likely to be. Equally, so is Kimi K2.5 1T params with 32B ac­tive, which is prob­a­bly ap­proach­ing the up­per limit of what you can ef­fi­ciently serve.

Here’s what the pric­ing looks like:

The Qwen 3.5 397B model on OpenRouter (via Alibaba Cloud) costs _$0.39_ per mil­lion in­put to­kens and _$2.34_ per mil­lion out­put to­kens. Compare that to Opus 4.6′s API pric­ing of $5/$25. Kimi K2.5 is even cheaper at $0.45 per mil­lion in­put to­kens and $2.25 out­put.

And this ra­tio holds for cached to­kens too - DeepInfra charges $0.07/MTok for cache reads on Kimi K2.5 vs Anthropic’s $0.50/MTok.

These OpenRouter providers are run­ning a busi­ness. They have to cover their com­pute costs, pay for GPUs, and make a mar­gin. They’re not char­i­ties. If so many can serve a model of com­pa­ra­ble size at ~10% of Anthropic’s API price and re­main in busi­ness, it is hard for me to be­lieve that they are all tak­ing enor­mous losses (at ~the ex­act same rate range).

If a heavy Claude Code Max user con­sumes $5,000 worth of to­kens at Anthropic’s re­tail API prices, and the ac­tual com­pute cost is roughly 10% of that, Anthropic is look­ing at ap­prox­i­mately $500 in real com­pute cost for the heav­i­est users.

That’s a loss of $300/month on the most ex­treme power users - not $4,800.

However, most users don’t come any­where near the limit. Anthropic them­selves said when they in­tro­duced weekly caps that fewer than 5% of sub­scribers would be af­fected. I per­son­ally use the Max 20x plan and prob­a­bly con­sume around 50% of my weekly to­ken bud­get and it’s hard to use that many to­kens with­out get­ting se­ri­ous RSI. At that level of us­age, the maths works out to roughly break-even or prof­itable for Anthropic.

The real story is ac­tu­ally in the ar­ti­cle. The $5,000 fig­ure comes from Cursor’s in­ter­nal analy­sis. And for Cursor, the num­ber prob­a­bly is roughly cor­rect - be­cause Cursor has to pay Anthropic’s re­tail API prices (or close to it) for ac­cess to Opus 4.6.

So to pro­vide a Claude Code-equivalent ex­pe­ri­ence us­ing Opus 4.6, it would cost Cursor ~$5,000 per power user per month. But it would cost Anthropic per­haps $500 max.

And the real is­sue for Cursor is that de­vel­op­ers want to use the Anthropic mod­els, even in Cursor it­self. They have real “brand aware­ness”, and they are gen­uinely bet­ter than the cheaper open weights mod­els - for now at least. It’s a real co­nun­drum for them.

Obviously Anthropic is­n’t print­ing free cash­flow. The costs of train­ing fron­tier mod­els, the enor­mous salaries re­quired to hire top AI re­searchers, the multi-bil­lion dol­lar com­pute com­mit­ments - these are gen­uinely mas­sive ex­penses that dwarf in­fer­ence costs.

But on a per-user, per-to­ken ba­sis for in­fer­ence? I be­lieve Anthropic is very likely prof­itable - po­ten­tially very prof­itable - on the av­er­age Claude Code sub­scriber.

The “AI in­fer­ence is a money pit” nar­ra­tive is mis­in­for­ma­tion that ac­tu­ally plays into the hands of the fron­tier labs. If every­one be­lieves that serv­ing to­kens is wildly ex­pen­sive, no­body ques­tions the 10x+ markups on API pric­ing. It dis­cour­ages com­pe­ti­tion and makes the moat look deeper than it is.

If you want to un­der­stand the real eco­nom­ics of AI in­fer­ence, don’t take API prices at face value. Look at what com­pet­i­tive open-weight model providers charge on OpenRouter. That’s a much closer proxy for what it ac­tu­ally costs to run these mod­els - and it’s a frac­tion of what the fron­tier labs charge.

I’ve been main­tain­ing Emacs Solo

for a while now, and I think it’s time to talk about what hap­pened in this lat­est cy­cle as the pro­ject reaches its two-year mark.

For those who haven’t seen it be­fore, Emacs Solo is my daily-dri­ver Emacs con­fig­u­ra­tion with one strict rule: no ex­ter­nal pack­ages. Everything is ei­ther built into Emacs or writ­ten from scratch by me in the lisp/ di­rec­tory. No pack­age-in­stall, no straight.el, no

use-pack­age :ensure t point­ing at ELPA or MELPA. Just Emacs and Elisp. I’m keep­ing this post text only, but if you’d like to check how

Emacs Solo looks and feels, the repos­i­tory has screen­shots and more de­tails.

Why? Partly be­cause I wanted to un­der­stand what Emacs ac­tu­ally gives you out of the box. Partly be­cause I wanted my con­fig to sur­vive with­out break­age across Emacs re­leases. Partly be­cause I was tired of deal­ing with pack­age repos­i­to­ries, mir­rors go­ing down in the mid­dle of the work­day, na­tive com­pi­la­tion hic­cups, and the in­evitable down­time when some­thing changed some­where up­stream and my job sud­denly be­came de­bug­ging my very long (at the time) con­fig in­stead of do­ing ac­tual work. And partly, hon­estly, be­cause it’s a lot of fun!

This post cov­ers the re­cent refac­tor, walks through every sec­tion of the core con­fig, in­tro­duces all 35 self-con­tained ex­tra mod­ules I’ve writ­ten, and shares some thoughts on what I’ve learned.

Now, I’ll be the first to ad­mit: this con­fig is long. But there’s a prin­ci­ple be­hind it. I only add fea­tures when they are not al­ready in Emacs core, and when I do, I try to build them my­self. That means the code is sketchy some­times, sure, but it’s in my con­trol. I wrote it, I un­der­stand it, and when it breaks, I know ex­actly where to look. The refac­tor I’m about to de­scribe makes this dis­tinc­tion crys­tal clear: what is “Emacs core be­ing tweaked” ver­sus what is “a re­ally hacky out­sider I built in be­cause I did­n’t want to live with­out it”.

The sin­gle biggest change in this cy­cle was ar­chi­tec­tural. Emacs Solo used to be one big init.el with every­thing crammed to­gether. That worked, but it had prob­lems:

— It was hard to nav­i­gate (even with out­line-mode)

— If some­one wanted just one piece, say my Eshell con­fig or my VC ex­ten­sions, they had to dig through thou­sands of lines

— It was dif­fi­cult to tell where “configuring built-in Emacs” ended and “my own hacky reim­ple­men­ta­tions” be­gan

The so­lu­tion was clean and sim­ple: split the con­fig into two lay­ers.

This file con­fig­ures only built-in Emacs pack­ages and fea­tures. Every

use-pack­age block in here has :ensure nil, be­cause it’s point­ing at some­thing that ships with Emacs. This is pure, stan­dard Emacs cus­tomiza­tion.

The idea is that any­one can read init.el, find a sec­tion they like, and

copy-paste it di­rectly into their own con­fig. No de­pen­den­cies. No setup. It just works, be­cause it’s con­fig­ur­ing things Emacs al­ready has.

These are my own im­ple­men­ta­tions: re­place­ments for pop­u­lar ex­ter­nal pack­ages, reimag­ined as small, fo­cused Elisp files. Each one is a proper pro­vide/​re­quire mod­ule. They live un­der lisp/ and are loaded at the bot­tom of init.el via a sim­ple block:

If you don’t want one of them, just com­ment out the re­quire line. If you want to use one in your own con­fig, just copy the .el file into your own lisp/ di­rec­tory and re­quire it. That’s it.

This sep­a­ra­tion made the whole pro­ject dra­mat­i­cally eas­ier to main­tain, un­der­stand, and share.

The init.el file is or­ga­nized into clearly la­beled sec­tions (using out­line-mode-friendly head­ers, so you can fold and nav­i­gate them in­side Emacs). Here’s every built-in pack­age and fea­ture it touches, and why.

The emacs use-pack­age block is the largest sin­gle sec­tion. It sets up sen­si­ble de­faults that most peo­ple would want:

— Window lay­out com­mands bound un­der C-x w (these are up­com­ing

Emacs 31 fea­tures: win­dow-lay­out-trans­pose,

win­dow-lay­out-ro­tate-clock­wise, win­dow-lay­out-flip-left­right,

win­dow-lay­out-flip-top­down)

— Disabling C-z (suspend) be­cause ac­ci­den­tally sus­pend­ing Emacs in a ter­mi­nal is never fun

— Sensible file han­dling: back­ups and auto-saves in a cache/

di­rec­tory, re­centf for re­cent files, clean buffer nam­ing with

uniquify

— Tree-sitter auto-in­stall and auto-mode (treesit-auto-install-grammar t and treesit-en­abled-modes t, both Emacs 31)

— delete-pair-push-mark, kill-re­gion-dwim, ibuffer-hu­man-read­able-size, all the small qual­ity-of-life set­tings com­ing in Emacs 31

A full ab­brev-mode setup with a cus­tom place­holder sys­tem. You de­fine ab­bre­vi­a­tions with ###1###, ###2### mark­ers, and when the ab­bre­vi­a­tion ex­pands, it prompts you to fill in each place­holder in­ter­ac­tively. The ###@### marker tells it where to leave point af­ter ex­pan­sion. I wrote a whole ar­ti­cle about it.

Configures auth-source to use ~/.authinfo.gpg for cre­den­tial stor­age. Simple but es­sen­tial if you use Gnus, ERC, or any net­work-fac­ing Emacs fea­ture.

Makes buffers au­to­mat­i­cally re­fresh when files change on disk. Essential for any Git work­flow.

Configuration file mode set­tings and a com­pi­la­tion-mode setup with ANSI color sup­port, so com­piler out­put ac­tu­ally looks read­able.

Custom win­dow man­age­ment be­yond the de­faults, be­cause Emacs win­dow man­age­ment out of the box is pow­er­ful but needs a lit­tle nudg­ing.

Tab-bar con­fig­u­ra­tion for work­space man­age­ment. Emacs has had tabs since ver­sion 27, and they’re gen­uinely use­ful once you con­fig­ure them prop­erly.

Two IRC clients, both built into Emacs, both con­fig­ured. ERC gets the big­ger treat­ment: log­ging, scroll­to­bot­tom, fill, match high­light­ing, and even in­line im­age sup­port (via one of the ex­tra mod­ules). The Emacs 31 cy­cle brought nice im­prove­ments here too, in­clud­ing a fix for the scroll­to­bot­tom/​fill-wrap de­pen­dency is­sue.

This is where Emacs Solo’s com­ple­tion story lives. Instead of reach­ing for Vertico, Consult, or Helm, I use icom­plete-ver­ti­cal-mode, which is built into Emacs. With the right set­tings it’s sur­pris­ingly ca­pa­ble:

I’ve also been con­tribut­ing patches up­stream to im­prove icom­plete’s ver­ti­cal ren­der­ing with pre­fix in­di­ca­tors. Some of those fea­tures are al­ready land­ing in Emacs 31, which means the poly­fill code I carry to­day will even­tu­ally be­come un­nec­es­sary.

A heav­ily cus­tomized Dired setup. Custom list­ing switches, hu­man read­able sizes, in­te­gra­tion with sys­tem open­ers (open on ma­cOS,

xdg-open on Linux), and the dired-hide-de­tails-hide-ab­solute-lo­ca­tion

op­tion from Emacs 31.

Writable Dired, so you can re­name files by edit­ing the buffer di­rectly.

This one I’m par­tic­u­larly proud of. Emacs Solo’s Eshell con­fig­u­ra­tion in­cludes:

— Shared his­tory across all Eshell buffers: Every Eshell in­stance reads from and writes to a merged his­tory, so you never lose a com­mand just be­cause you ran it in a dif­fer­ent buffer

— Custom prompts: Multiple prompt styles you can tog­gle be­tween with C-c t (full vs. min­i­mal) and C-c T (lighter vs. heav­ier full prompt)

This is one of the largest sec­tions and one I’m most in­vested in. Emacs’s built-in vc is an in­cred­i­ble piece of soft­ware that most peo­ple over­look in fa­vor of Magit. I’m not say­ing it re­places Magit en­tirely, but with the right con­fig­u­ra­tion it cov­ers 95% of daily Git op­er­a­tions:

— Git add/​re­set from vc-dir: S to stage, U to un­stage, di­rectly in the vc-dir buffer. Admittedly, I al­most never use this be­cause I’m now used to the Emacs-style VC work­flow: C-x v D or C-x v =, then killing what I don’t want, split­ting what is­n’t ready yet, and fin­ish­ing with C-c C-c. Amending with C-c C-e is awe­some. Still use­ful once or twice a se­mes­ter.

— Browse re­mote: C-x v B opens your repos­i­tory on GitHub/GitLab in a browser; with a pre­fix ar­gu­ment it jumps to the cur­rent file and line

— Jump to cur­rent hunk: C-x v = opens the diff buffer scrolled to the hunk con­tain­ing your cur­rent line

— Switch be­tween mod­i­fied files: C-x C-g lets you

com­plet­ing-read through all mod­i­fied/​un­tracked files in the cur­rent repo

Merge con­flict res­o­lu­tion and diff view­ing. Ediff con­fig­ured to split win­dows sanely (side by side, not in a new frame).

Documentation at point, with el­doc-help-at-pt (Emacs 31) for show­ing docs au­to­mat­i­cally.

The LSP client that ships with Emacs. Configured with:

— Custom server pro­grams, in­clud­ing ras­sum­fras­sum for mul­ti­plex­ing TypeScript + ESLint + Tailwind (I wrote a whole post

about that)

— Keybindings un­der C-c l for code ac­tions, re­name, for­mat, and in­lay hints

— Automatic en­abling for all prog-mode buffers ex­cept

emacs-lisp-mode and lisp-mode

Diagnostics, spell check­ing, and white­space vi­su­al­iza­tion. All built-in, all con­fig­ured.

The Emacs news­reader and email client. Configured for IMAP/SMTP us­age.

RSS/Atom feed reader built into Emacs. Customized with some ex­tras I build my self for deal­ing with youtube feeds: thumb­nail, tran­scripts, send­ing to AI for a quick sum­mary, and so on.

Org-mode con­fig­u­ra­tion, be­cause of course.

File tree nav­i­ga­tion in a side win­dow. With Emacs 31, speed­bar gained speed­bar-win­dow sup­port, so it can live in­side your ex­ist­ing frame in­stead of spawn­ing a new one.

Buffer name dis­am­bigua­tion when you have mul­ti­ple files with the same name open.

Quick web searches from the minibuffer. Configured with use­ful search en­gines.

Specific con­fig­u­ra­tions for every lan­guage I work with, or­ga­nized into three ar­eas:

Common Lisp: in­fe­rior-lisp and lisp-mode with cus­tom REPL in­ter­ac­tion, eval­u­a­tion com­mands, and a poor man’s SLIME/SLY setup that ac­tu­ally works quite well for ba­sic Common Lisp de­vel­op­ment.

Non-Tree-sitter: sass-mode for when tree-sit­ter gram­mars aren’t avail­able.

Tree-sitter modes: ruby-ts-mode, js-ts-mode,

json-ts-mode, type­script-ts-mode, bash-ts-mode,

rust-ts-mode, toml-ts-mode, mark­down-ts-mode (Emacs 31),

yaml-ts-mode, dock­er­file-ts-mode, go-ts-mode. Each one con­fig­ured with tree-sit­ter gram­mar sources (which Emacs 31 is start­ing to de­fine in­ter­nally, so those de­f­i­n­i­tions will even­tu­ally be­come un­nec­es­sary).

This is where the fun re­ally is. Each of these is a com­plete, stand­alone Elisp file that reim­ple­ments func­tion­al­ity you’d nor­mally get from an ex­ter­nal pack­age. They’re all in lisp/ and can be used in­de­pen­dently.

I call them “hacky reim­ple­men­ta­tions” in the spirit of Emacs Solo: they’re not try­ing to be fea­ture-com­plete re­place­ments for their MELPA coun­ter­parts. They’re try­ing to be small, un­der­stand­able,

and good enough for daily use while keep­ing the con­fig self-con­tained.

Custom color themes based on Modus. Provides sev­eral theme vari­ants: Catppuccin Mocha, Crafters (the de­fault), Matrix, and GITS. All built on top of Emacs’s built-in Modus themes by over­rid­ing faces, so you get the ac­ces­si­bil­ity and com­plete­ness of Modus with dif­fer­ent aes­thet­ics.

Custom mode-line for­mat and con­fig­u­ra­tion. A hand-crafted mode-line that shows ex­actly what I want: buffer state in­di­ca­tors, file name, ma­jor mode, Git branch, line/​col­umn, and noth­ing else. No doom-mod­e­line, no tele­phone-line, just for­mat strings and faces.

Enhanced nav­i­ga­tion and win­dow move­ment com­mands. Extra com­mands for mov­ing be­tween win­dows, re­siz­ing splits, and nav­i­gat­ing buffers more ef­fi­ciently.

Configurable for­mat-on-save with a for­mat­ter reg­istry. You reg­is­ter for­mat­ters by file ex­ten­sion (e.g., pret­tier for .tsx,

black for .py), and the mod­ule au­to­mat­i­cally hooks into

af­ter-save-hook to for­mat the buffer. All con­trol­lable via a

de­f­cus­tom, so you can tog­gle it on and off glob­ally.

Frame trans­parency for GUI and ter­mi­nal. Toggle trans­parency on your Emacs frame. Works on both graph­i­cal and ter­mi­nal Emacs, us­ing the ap­pro­pri­ate mech­a­nism for each.

Sync shell PATH into Emacs. The clas­sic ma­cOS prob­lem: GUI Emacs does­n’t in­herit your shel­l’s PATH. This mod­ule solves it the same way exec-path-from-shell does, but in about 20 lines in­stead of a full pack­age.

Rainbow col­or­ing for match­ing de­lim­iters. Colorizes nested paren­the­ses, brack­ets, and braces in dif­fer­ent col­ors so you can vi­su­ally match nest­ing lev­els. Essential for any Lisp, and help­ful every­where else.

Interactive pro­ject finder and switcher. A com­plet­ing-read

in­ter­face for find­ing and switch­ing be­tween pro­jects, build­ing on Emacs’s built-in pro­ject.el.

Vim-like key­bind­ings and text ob­jects for Viper. If you use Emacs’s built-in viper-mode (the Vim em­u­la­tion layer), this ex­tends it with text ob­jects and ad­di­tional Vim-like com­mands. No Evil needed.

Highlight TODO and sim­i­lar key­words in com­ments. Makes TODO,

FIXME, HACK, NOTE, and sim­i­lar key­words stand out in source code com­ments with dis­tinc­tive faces. A small thing that makes a big dif­fer­ence.

Git diff gut­ter in­di­ca­tors in buffers. Shows added, mod­i­fied, and deleted line in­di­ca­tors in the mar­gin, like diff-hl or

git-gut­ter. Pure Elisp, us­ing vc-git un­der the hood.

Quick win­dow switch­ing with la­bels. When you have three or more win­dows, this over­lays sin­gle-char­ac­ter la­bels on each win­dow so you can jump to any one with a sin­gle key­stroke. A min­i­mal reim­ple­men­ta­tion of the pop­u­lar ace-win­dow pack­age.

Centered doc­u­ment lay­out mode. Centers your text in the win­dow with wide mar­gins, like olivetti-mode. Great for prose writ­ing, Org doc­u­ments, or any time you want a dis­trac­tion-free cen­tered lay­out.

Upload text and files to 0x0.st. Select a re­gion or a file and up­load it to the 0x0.st paste ser­vice. The URL is copied to your kill ring. Quick and use­ful for shar­ing snip­pets.

Edit files as root via TRAMP. Reopen the cur­rent file with root priv­i­leges us­ing TRAMP’s /sudo:: pre­fix. A reim­ple­men­ta­tion of the

WorldThe thing that every­one ex­pected to hap­pen has hap­pened­Gold­man pitches hedge funds on strate­gies to bet against cor­po­rate loansSaudi Aramco warns of ‘catastrophic con­se­quences’ if Iran war drags onUS­Gold­man pitches hedge funds on strate­gies to bet against cor­po­rate loan­sIran is a cru­cial test case for the American way of war­Com­pa­nies­Gold­man pitches hedge funds on strate­gies to bet against cor­po­rate loan­sYann LeCun’s AI start-up raises more than $1bn in Europe’s largest seed round­Saudi Aramco warns of ‘catastrophic con­se­quences’ if Iran war drags on­TechYann LeCun’s AI start-up raises more than $1bn in Europe’s largest seed round­Mar­ket­s­The thing that every­one ex­pected to hap­pen has hap­pened­Gold­man pitches hedge funds on strate­gies to bet against cor­po­rate loansSaudi Aramco warns of ‘catastrophic con­se­quences’ if Iran war drags onOpin­ion­The thing that every­one ex­pected to hap­pen has hap­penedI­ran is a cru­cial test case for the American way of war­Work & CareersWhite men will have ‘fewer board seats’ in fu­ture, says UK di­ver­sity chair Why it’s time to end the grim march of the touch­screen­Venice’s ci­c­chetti re­nais­sance: where to find the city’s best bar snacksYou can turn this to your ad­van­tage if every news story has ‘tax ex­ile’ in itLife & ArtsRoy Chan can turn you into Austin ButlerThe world’s most ex­pen­sive prop­er­ties are su­per­charg­ing their se­cu­ri­ty­Wine stor­age is emerg­ing from the cel­lar How To Spend It

Yann LeCun’s AI start-up raises more than $1bn in Europe’s largest seed round per month.

Complete dig­i­tal ac­cess to qual­ity FT jour­nal­ism on any de­vice.

Cancel any­time dur­ing your trial. Access to eight sur­pris­ing ar­ti­cles a day, hand-picked by FT ed­i­tors. For seam­less read­ing, ac­cess con­tent via the FT Edit page on FT.com and re­ceive the FT Edit newslet­ter.Es­sen­tial dig­i­tal ac­cess to qual­ity FT jour­nal­ism on any de­vice. Pay a year up­front and save 20%.Complete dig­i­tal ac­cess to qual­ity FT jour­nal­ism with ex­pert analy­sis from in­dus­try lead­ers. Pay a year up­front and save 20%.Check whether you al­ready have ac­cess via your uni­ver­sity or or­gan­i­sa­tion.Dis­cover all the plans cur­rently avail­able in your coun­try­See why over a mil­lion read­ers pay to read the Financial Times.Find out why

How To Spend It

Background: Why I put my whole life into a sin­gle data­base

Back in 2019, I started col­lect­ing all kinds of met­rics about my life. Every sin­gle day for the last 3 years I tracked over 100 dif­fer­ent data types - rang­ing from fit­ness & nu­tri­tion to so­cial life, com­puter us­age and weather.

Ideas or sug­ges­tions?

I’d love to hear from you!

The goal of this pro­ject was to an­swer ques­tions about my life, like

How does liv­ing in dif­fer­ent cities af­fect other fac­tors like fit­ness, pro­duc­tiv­ity and hap­pi­ness?

How does sleep af­fect my day, my fit­ness level, and hap­pi­ness?

How does the weather, and the dif­fer­ent sea­sons af­fect my life?

Are there any trends over the last few years?

How does com­puter time, work and hours in meet­ings af­fect my per­sonal life?

Since the start of this pro­ject, I col­lected ~380,000 data points, with the biggest data sources be­ing:

Naturally af­ter I started col­lect­ing this data, I wanted to vi­su­al­ize what I was learn­ing, so I cre­ated this page. Initially, the do­main where­is­Fe­lix.to­day (now re­named to how­is­Fe­lix.to­day) started as a joke to re­spond to friends ask­ing when I’d be back in NYC or San Francisco. Rather than send them my sched­ule, I’d point them to this do­main. However, now it’s more than my lo­ca­tion: it’s all of me.

Use a sin­gle data­base, owned and hosted by me, with all the data I’ve col­lected over the years

Be able to eas­ily add and re­move ques­tions on the fly, as I learn what’s ben­e­fi­cial to track

Full con­trol of how the data is vi­su­al­ized

Works well for fre­quent fly­ers with mixed time zones

I se­lected 48 graphs to show pub­licly on this page. For pri­vacy rea­sons, and to pre­vent any ac­ci­den­tal data leaks, the graphs be­low are snap­shots taken on a given day.

Visualization of the num­ber of data en­tries in FxLifeSheet over the last 10 years, and where the data came from.

Initially (2014) the only data used was RescueTime and Foursquare Swarm lo­ca­tion data

Once I started the FxLifeSheet pro­ject in April 2019, I man­u­ally tracked , rang­ing from mood, sleep, so­cial life, to fit­ness data

I was able to ret­ro­spec­tively fetch the his­toric weather data based on my lo­ca­tion on a given day

I also im­ple­mented other im­port sources, like fetch­ing my his­toric weight and the num­ber of steps from Apple Health

Days tracked my Mood to be Happy & Excited

On days where I tracked my mood to be “happy” & “excited”, the fol­low­ing other fac­tors of my life were af­fected

50% more likely to have pushed my com­fort zone

44% more likely to have med­i­tated that day

33% more ex­cited about what’s ahead in the fu­ture

31% more likely to drink al­co­hol that day (parties, good friends and such)

28% more time spent read­ing or lis­ten­ing to au­dio books

26% more likely to have worked on in­ter­est­ing tech­ni­cal chal­lenges

20% more likely to have learned some­thing new that day

45% less time spent in video & au­dio calls that day

All flights taken within the last 7 years, tracked us­ing Foursquare Swarm, an­a­lyzed by JetLovers.

The stats clearly show the im­pact of COVID start­ing 2020

Sunday has been my “commute” day, fly­ing be­tween San Francisco, New York City and Vienna

All flights taken within the last 7 years, tracked us­ing Foursquare Swarm, an­a­lyzed by JetLovers.

Frankfurt - Vienna was the flight con­nect­ing me with most US air­ports

Germany is high up on the list due to lay­overs, even though I did­n’t spend ac­tu­ally much time there

Inspired by Your Life in Weeks by WaitButWhy, I use Google Sheets to vi­su­al­ize every week of my life, with lit­tle notes on what city/​coun­try I was in, and other life events that have hap­pened.

The first 14 years I did­n’t re­ally get much done

I can highly rec­om­mend tak­ing a few weeks (or even months) off be­tween jobs (if you have the pos­si­bil­ity)

Shades of blue in­di­cate my full-time em­ploy­ments

You can cre­ate your own ver­sion us­ing my tem­plate

Average daily steps mea­sured through the iPhone’s Apple Health app. I de­cided against us­ing SmartWatch data for steps, as SmartWatches have changed over the last 8 years.

I walked a to­tal of steps over last 8 years

I walk more than twice as much when I’m in New York, com­pared to any other city

In NYC I had the gen­eral rule of thumb to walk in­stead of tak­ing pub­lic tran­sit when­ever it’s less than 40 min­utes. I used that time to call friends & fam­ily, or lis­ten to au­dio books

Although Vienna is very walk­a­ble, the ex­cel­lent pub­lic tran­sit sys­tem with sub­way trains com­ing every 3-5 min­utes, has caused me to walk less

San Francisco was al­ways scary to walk

This graph clearly shows the cor­re­la­tion be­tween my body weight and my sleep­ing/​rest­ing heart rate. The rest­ing heart rate is mea­sured by the Withings ScanWatch while sleep­ing, and in­di­cates how hard your heart has to work while not be­ing ac­tive. Generally the lower the rest­ing heart rate, the bet­ter.

I started my lean bulk (controlled weight gain com­bined with 5 work­outs a week) in August 2020

My rest­ing heart rate went from 58bpm to 67bpm () from August 2020 to March 2021 with a weight gain of (+19lbs) as part of a con­trolled lean-bulk com­bined with a 5-day/week work­out rou­tine

The spike in rest­ing heart rate in July & August 2021 was due to bars and night­clubs open­ing up again in Austria

After a night of drink­ing, my rest­ing/​sleep­ing heart rate was about 50% higher than af­ter a night with­out any al­co­hol

The spike in rest­ing heart rate in Oct/Nov/Dec 2021 was due to hav­ing bron­chi­tis and a cold/​flu, not get­ting cor­rect treat­ment early enough

How healthy have I been over the Years?

Every day I an­swered the ques­tion on how healthy I felt. In the graph, the yel­low color in­di­cates that I felt a lit­tle un­der the weather, not sick per se. Red means I was sick and had to stay home. Green means I felt en­er­gized and healthy.

During the COVID lock­downs I tended to stay health­ier. This may be due to not go­ing out, no heavy drink­ing, less close con­tact with oth­ers, etc. which re­sulted in me hav­ing bet­ter sleep.

Usually dur­ing ex­ces­sive trav­el­ing I get sick (cold/flu)

Q4 2021 I had bron­chi­tis, how­ever, I did­n’t know about it at the time and did­n’t get proper treat­ment

Overall I’m quite prone to get­ting sick (cold/flu)

Days with more than 4 Alcoholic Drinks

On days where I had more than 4 al­co­holic bev­er­ages (meaning I was par­ty­ing), the fol­low­ing other fac­tors were af­fected

21x more likely to dance

80% more likely to take a nap the day of, or the day af­ter

40% warmer tem­per­a­tures, and 40% less pre­cip­i­ta­tion. There weren’t many op­por­tu­ni­ties for par­ties in Winter due to lock­downs in the last 2 years. Also, peo­ple are more mo­ti­vated to go out when it’s nice out­side.

My FxLifeSheet bot asks me 4 times a day how I’m feel­ing at the mo­ment.

This graph groups the en­tries by month, and shows the % of en­tries for each value (0 - 5) with 5 be­ing very ex­cited, and 0 be­ing wor­ried.

I de­signed the ranges so that 0 or 5 are not en­tered as much. 0 is ren­dered as dark green at the top, whereas 5 is ren­dered as light green at the bot­tom.

For pri­vacy rea­sons I won’t get into some of the de­tails on why cer­tain months were worse than oth­ers.

Every Swarm check-in over the last 7 years vi­su­al­ized on a map, in­clud­ing the ac­tual trip (flight, drive, etc.)

Every Swarm check-in over the last 7 years vi­su­al­ized, zoomed in

Each time I did a check-in at a place (e.g. Coffee, Restaurant, Airport, Gym) on Foursquare Swarm at a given city, this is tracked as a sin­gle en­try.

Each check-in at a given city is counted as a sin­gle en­try, grouped by years

2018 and 2019 I lived in New York City

The longer it’s been since I moved away from Austria, the more time I ac­tu­ally spent back home in Austria for vis­its and va­ca­tions

2020 clearly shows the im­pact of COVID

Each check-in at a given cat­e­gory is tracked, and summed up over the last years

In 2020 and 2021, check-ins at Offices went down to zero due to COVID, and a dis­trib­uted work setup

Airports be­ing the #4 most vis­ited cat­e­gory was a sur­prise, but is ac­cu­rate. A to­tal of 403 air­port check-ins, whereas a flight with a lay­over would count as 3 air­port check-ins

Earlier in my life, I did­n’t al­ways check into ‘commute’ places like pub­lic tran­sit and su­per mar­kets

Number of Foursquare Swarm check-ins on each quar­ter over the last 10 years. I did­n’t use Foursquare Swarm as se­ri­ously be­fore 2015. Once I moved to San Francisco in Q3 2015 I started my habit of check­ing into every point of in­ter­est (POI) I visit.

Q3 2015 I moved to San Francisco, how­ever I could­n’t use Swarm yet, since my move was a se­cret un­til the of­fi­cial an­nounced at the Twitter Flight con­fer­ence

Q2 2020 clearly shows the im­pact of COVID with Q3 al­ready be­ing open in Austria

Q3 2021 the vac­cine was al­ready widely avail­able and I was able to travel/​visit more again

My time in New York was the most ac­tive when it comes to check-ins. When I’m in NYC, I tend to eat/​drink out more, and grab to-go food, which I do way less in Vienna

Every Swarm check-in vi­su­al­ized on a map. Only ar­eas where I’ve had mul­ti­ple check-ins are ren­dered.

Number of days per year that I’ve spent in full lock­down, mean­ing restau­rants, bars and non-es­sen­tial stores were closed.

I es­caped parts of the Austrian lock­down by spend­ing time in the US when I was al­ready vac­ci­nated

Surprisingly 2021 I spent more days in a full lock­down than in 2020, even with vac­cines avail­able

How was my life af­fected by the re­cent COVID lock­downs? As lock­down day I clas­sify every day where places like restau­rants, gyms and non-es­sen­tial stores were closed.

200% more time spent in au­dio & video calls with friends (non-work re­lated)

60% more likely to fol­low my meal plan (macros & calo­ries)

50% colder tem­per­a­tures: Lockdowns tended to hap­pen in Autumn and Winter

100% less likely to dance

Alcoholic drinks per day. Days with no data are ren­dered as white

Friday and Saturday nights are clearly vis­i­ble on those graphs

2021 and sum­mer/​win­ter of 2019 also show the Wednesday night party in Vienna

Q2 and Q4 2020 clearly show the COVID lock­downs, as well as Q2 2021

Summer of 2021 all bars and dance clubs were open in Vienna