Today we’re launch­ing Claude Fable 5: a Mythos-class1 model that we’ve made safe for gen­eral use.

Fable 5’s ca­pa­bil­i­ties ex­ceed those of any model we’ve ever made gen­er­ally avail­able. It is state-of-the-art on nearly all tested bench­marks of AI ca­pa­bil­ity, show­ing ex­cep­tional per­for­mance in soft­ware en­gi­neer­ing, knowl­edge work, vi­sion, sci­en­tific re­search, and many other ar­eas. The longer and more com­plex the task, the larger Fable 5’s lead over our other mod­els.

Releasing a model this ca­pa­ble comes with risks. Without safe­guards, Fable 5’s ca­pa­bil­i­ties in ar­eas like cy­ber­se­cu­rity could be mis­used to cause se­ri­ous dam­age. We’ve there­fore launched the model with safe­guards that mean queries on some top­ics will in­stead re­ceive a re­sponse from our next-most-ca­pa­ble model, Claude Opus 4.8. To re­lease the model both safely and quickly, we’ve tuned these safe­guards con­ser­v­a­tively—they’ll some­times catch harm­less re­quests, though they trig­ger, on av­er­age, in less than 5% of ses­sions. With more ca­pa­ble mod­els ar­riv­ing in the com­ing months, we’re work­ing to im­prove our safe­guards and re­duce false pos­i­tives as quickly as we can.

For a small group of cy­berde­fend­ers and in­fra­struc­ture providers, we’re also launch­ing Claude Mythos 5. It’s the same un­der­ly­ing model as Fable 5, but with the safe­guards lifted in some ar­eas.2 Mythos 5 will ini­tially be de­ployed through Project Glasswing, in col­lab­o­ra­tion with the US gov­ern­ment, as an up­grade to Claude Mythos Preview. It has the strongest cy­ber­se­cu­rity ca­pa­bil­i­ties of any model in the world. Soon, we in­tend to ex­pand ac­cess to Mythos 5 through a broader trusted ac­cess pro­gram.

The ca­pa­bil­i­ties of mod­els like Fable 5 and Mythos 5 have the po­ten­tial to do pro­found good for the world. We’ve seen the be­gin­nings of this in Project Glasswing, where the mod­els have helped cy­ber de­fend­ers se­cure crit­i­cally im­por­tant soft­ware. We’ve also seen it in life sci­ences re­search, where the mod­els are posit­ing novel hy­pothe­ses and speed­ing up the de­vel­op­ment of new ther­a­peu­tics.

Fable 5 and Mythos 5 are be­ing of­fered at $10 per mil­lion in­put to­kens and $50 per mil­lion out­put to­kens—less than half the price of Claude Mythos Preview. Today’s joint launch is an­other step to­wards our goal of bring­ing ad­vanced AI ca­pa­bil­i­ties to as many users as pos­si­ble, as quickly and as safely as we can.

The table be­low com­pares the ca­pa­bil­i­ties of Fable 5 and Mythos 5 to other lead­ing mod­els.

Fable 5 and Mythos 5 can work au­tonomously for longer than any pre­vi­ous Claude mod­els. Below we dis­cuss how these skills ap­ply to soft­ware en­gi­neer­ing, and cover the mod­el’s im­proved ca­pa­bil­i­ties in knowl­edge work, vi­sion, mem­ory, and life sci­ences re­search.

Software en­gi­neer­ing. During early test­ing, Stripe re­ported that Fable 5 com­pressed months of en­gi­neer­ing into days. In a 50-million-line Ruby code­base, the model per­formed a code­base-wide mi­gra­tion in a day that would oth­er­wise have taken a whole team over two months by hand. Fable 5 is also more to­ken-ef­fi­cient than past Claude mod­els: on Cognition’s FrontierCode eval­u­a­tion, which tests whether mod­els can pass dif­fi­cult cod­ing tasks while meet­ing the stan­dards of high-qual­ity pro­duc­tion code­bases, Fable 5 scores high­est among fron­tier mod­els, even at medium ef­fort.

Knowledge work. Fable 5 shows strong per­for­mance on com­plex an­a­lyt­i­cal tasks. On Hebbia’s Finance Benchmark for se­nior-level rea­son­ing, Fable 5 has the high­est score of any model, with sub­stan­tial gains in doc­u­ment-based rea­son­ing, chart and table in­ter­pre­ta­tion, and prob­lem solv­ing. IMC noted that Fable 5 aced their trad­ing-analy­sis eval­u­a­tions nearly across the board, in­clud­ing fac­tual lookup, con­cep­tual rea­son­ing, root-cause analy­sis, and ex­pected-value analy­sis.

Vision. Fable 5 is the new state-of-the-art model for tasks in­volv­ing vi­sion. It can ex­tract pre­cise num­bers from de­tailed sci­en­tific fig­ures and can per­form com­plex vi­sion-based tasks like re­build­ing a web ap­p’s source code from screen­shots alone. It also needs less scaf­fold­ing: for ex­am­ple, pre­vi­ous Claude mod­els strug­gled to play Pokémon FireRed even with har­nesses that gave them ad­di­tional help­ful tools, but Fable 5 beat FireRed with a min­i­mal, vi­sion-only har­ness.

Memory and long-con­text. Fable 5 stays fo­cused across mil­lions of to­kens in long-run­ning tasks and im­proves its out­puts us­ing its own notes. When we had the model play the deck-build­ing game Slay the Spire, giv­ing it ac­cess to per­sis­tent file-based mem­ory im­proved its per­for­mance three times more than for Opus 4.8; Fable also reached the game’s fi­nal act three times more of­ten.

Drug de­sign: Using Mythos 5, our in­ter­nal pro­tein de­sign ex­perts ac­cel­er­ated as­pects of the drug de­sign process by around ten times. In one ex­am­ple, they found that Mythos 5, with pro­tein de­sign and bioin­for­mat­ics tools but no hu­man as­sis­tance, matches or beats skilled hu­man op­er­a­tors. In do­ing so, the model ex­e­cutes all of the tasks that are nor­mally com­pleted by a sci­en­tist: choos­ing bind­ing sites, se­lect­ing and run­ning pro­tein de­sign tools, and re­cov­er­ing from fail­ures along the way. Nine of the 14 pro­tein tar­gets from this study (shown be­low) yielded strong can­di­dates for drug de­sign that we’re cur­rently in­ves­ti­gat­ing.

Novel hy­pothe­ses in mol­e­c­u­lar bi­ol­ogy. Mythos 5 is our first model to con­sis­tently pro­duce novel, com­pelling sci­en­tific hy­pothe­ses. In blinded head-to-head com­par­isons against Opus-class mod­els, our sci­en­tists pre­ferred Mythos’s mol­e­c­u­lar bi­ol­ogy hy­pothe­ses ~80% of the time, and have ad­vanced sev­eral to ex­per­i­men­tal eval­u­a­tion. In the mean­time, one Mythos hy­poth­e­sis—a novel mech­a­nism for an E. coli pro­tein—was cor­rob­o­rated in a study from a lab in­de­pen­dently work­ing on the same prob­lem.

Novel re­search in ge­nomics. Mythos 5 con­ducted novel ge­nomics re­search in over a week of largely au­tonomous work. It as­sem­bled sin­gle-cell data for mil­lions of cells span­ning 138 an­i­mal species and de­signed and trained a cus­tom ma­chine learn­ing model to iden­tify cells per­form­ing the same role in even dis­tantly re­lated or­gan­isms. With only high-level hu­man in­put, Mythos 5’s trained model out­per­formed a re­cent model pub­lished in the jour­nal Science—despite be­ing 100 times smaller. We in­tend to pub­lish these re­sults in the com­ing months.

Alignment. In our au­to­mated align­ment as­sess­ment we found that Mythos 5’s level of mis­aligned be­hav­ior (including mis­aligned ac­tions taken by the model such as de­cep­tion, and co­op­er­a­tion with mis­use of the model by a user) was low, and sim­i­lar to that of Opus 4.8. Given they are the same un­der­ly­ing model, Fable 5’s level of align­ment will be sim­i­lar. The as­sess­ment is de­scribed in full, along with a de­tailed suite of other safety and ca­pa­bil­i­ties tests, in the mod­el’s sys­tem card.

Early feed­back for Claude Fable 5

Customers with early ac­cess ran their own tests on Fable 5. Below, in their words, is a se­lec­tion of what they’re see­ing:

Claude Fable 5 is the state of the art model on CursorBench. It’s opened up a class of long-hori­zon prob­lems that were out of reach for ear­lier mod­els.

Claude Fable 5 is the state of the art model on CursorBench. It’s opened up a class of long-hori­zon prob­lems that were out of reach for ear­lier mod­els.

Claude Fable 5 is a real step for­ward for the de­vel­op­ers GitHub serves. In our early test­ing, it took on com­plex, long-hori­zon cod­ing tasks with a level of au­ton­omy and re­li­a­bil­ity that ex­ceeded pre­vi­ous bench­marks. But what ex­cites us most is the di­rec­tion it points: a fu­ture where de­vel­op­ers can hand in­creas­ingly am­bi­tious work to agents and trust the re­sults across the soft­ware life­cy­cle.

Claude Fable 5 is a real step for­ward for the de­vel­op­ers GitHub serves. In our early test­ing, it took on com­plex, long-hori­zon cod­ing tasks with a level of au­ton­omy and re­li­a­bil­ity that ex­ceeded pre­vi­ous bench­marks. But what ex­cites us most is the di­rec­tion it points: a fu­ture where de­vel­op­ers can hand in­creas­ingly am­bi­tious work to agents and trust the re­sults across the soft­ware life­cy­cle.

These are the strongest re­sults of any Claude model we’ve had the op­por­tu­nity to test. Claude Fable 5 is a clear step for­ward on agen­tic cod­ing and pro­to­typ­ing.

These are the strongest re­sults of any Claude model we’ve had the op­por­tu­nity to test. Claude Fable 5 is a clear step for­ward on agen­tic cod­ing and pro­to­typ­ing.

Claude Fable 5′s rea­son­ing is a clear step be­yond Opus 4.8. It works at se­nior re­search sci­en­tist grade — pick­ing di­rec­tions, al­lo­cat­ing re­sources, killing its in­cor­rect be­liefs, and pro­duc­ing novel first-prin­ci­ples out­puts.

Claude Fable 5′s rea­son­ing is a clear step be­yond Opus 4.8. It works at se­nior re­search sci­en­tist grade — pick­ing di­rec­tions, al­lo­cat­ing re­sources, killing its in­cor­rect be­liefs, and pro­duc­ing novel first-prin­ci­ples out­puts.

Claude Fable 5 un­der­stands what builders mean, not just what they type. Apps that took a hun­dred prompts a year ago, it now one-shots. When a cus­tomer re­ally hits a wall, it’s the model we reach for to get them past it quickly, so they can fin­ish what they set out to build.

Claude Fable 5 un­der­stands what builders mean, not just what they type. Apps that took a hun­dred prompts a year ago, it now one-shots. When a cus­tomer re­ally hits a wall, it’s the model we reach for to get them past it quickly, so they can fin­ish what they set out to build.

Claude Fable 5 feels ma­te­ri­ally dif­fer­ent. In blind re­view, our lawyers found its red­lines matched or beat our cur­rent model every time.

Claude Fable 5 feels ma­te­ri­ally dif­fer­ent. In blind re­view, our lawyers found its red­lines matched or beat our cur­rent model every time.

At the high­est ef­fort, Claude Fable 5 re­flects on and val­i­dates its own work. For us, that’s what makes highly au­tonomous op­er­a­tions pos­si­ble — the ex­tra think­ing pays for it­self.

At the high­est ef­fort, Claude Fable 5 re­flects on and val­i­dates its own work. For us, that’s what makes highly au­tonomous op­er­a­tions pos­si­ble — the ex­tra think­ing pays for it­self.

Claude Fable 5 de­liv­ers more ca­pa­ble en­gi­neer­ing in fewer turns than prior mod­els — han­dling the com­plex multi-agent work­flows our em­ploy­ees run daily in Claude Code.

Claude Fable 5 de­liv­ers more ca­pa­ble en­gi­neer­ing in fewer turns than prior mod­els — han­dling the com­plex multi-agent work­flows our em­ploy­ees run daily in Claude Code.

Claude Fable 5 is the high­est-scor­ing model on FrontierBench, Cognition’s fron­tier cod­ing eval. It ex­cels at long-hori­zon rea­son­ing and gen­er­al­izes to un­fa­mil­iar tools out of the box.

Claude Fable 5 is the high­est-scor­ing model on FrontierBench, Cognition’s fron­tier cod­ing eval. It ex­cels at long-hori­zon rea­son­ing and gen­er­al­izes to un­fa­mil­iar tools out of the box.

Claude Fable 5 is the strongest fi­nance-first model we’ve tested, both on gen­eral fi­nance and rea­son­ing. It’s a no­table step up.

Claude Fable 5 is the strongest fi­nance-first model we’ve tested, both on gen­eral fi­nance and rea­son­ing. It’s a no­table step up.

Claude Fable 5 is the first to break 90% on our core an­a­lyt­ics bench­mark of com­plex, long-run­ning an­a­lyt­i­cal tasks — a 10-point jump over Opus. On the hard­est ques­tions, it shows strong judg­ment and at­ten­tion to nu­ance.

Claude Fable 5 is the first to break 90% on our core an­a­lyt­ics bench­mark of com­plex, long-run­ning an­a­lyt­i­cal tasks — a 10-point jump over Opus. On the hard­est ques­tions, it shows strong judg­ment and at­ten­tion to nu­ance.

Claude Fable 5 is the strongest model we’ve tested on fron­tier physics re­search while us­ing a third of the rea­son­ing to­kens. In 36 hours it got nearly to where GPT-5.5 landed af­ter four days.

Claude Fable 5 is the strongest model we’ve tested on fron­tier physics re­search while us­ing a third of the rea­son­ing to­kens. In 36 hours it got nearly to where GPT-5.5 landed af­ter four days.

On ViBench, our end-to-end vibe-cod­ing bench­mark, Claude Fable 5 is the high­est-per­form­ing model we’ve tested — nearly sat­u­rat­ing our base use cases and build­ing apps in less time with fewer to­kens.

On ViBench, our end-to-end vibe-cod­ing bench­mark, Claude Fable 5 is the high­est-per­form­ing model we’ve tested — nearly sat­u­rat­ing our base use cases and build­ing apps in less time with fewer to­kens.

Claude Fable 5 beats Opus 4.8 on our every­day spread­sheet suite at every ef­fort level — and it does it with fewer turns, fin­ish­ing runs 25 – 30% faster.

Claude Fable 5 beats Opus 4.8 on our every­day spread­sheet suite at every ef­fort level — and it does it with fewer turns, fin­ish­ing runs 25 – 30% faster.

01 /

14

Claude Fable 5’s new safe­guards

Mythos-class mod­els have reached a thresh­old where they pre­sent sig­nif­i­cant risks. In April we be­gan Project Glasswing, re­leas­ing the first Mythos-class model (Claude Mythos Preview) to only a lim­ited group of cy­ber de­fend­ers and crit­i­cal soft­ware in­fra­struc­ture providers. When we did so, we stated that we hoped to even­tu­ally re­lease Mythos-level ca­pa­bil­i­ties to all our users, so long as we had de­vel­oped new safe­guards that were strong enough to re­li­ably pre­vent mis­use.

Over the past few months we have been im­prov­ing these safe­guards, and they are now ro­bust enough for a gen­eral re­lease. Because we have pri­or­i­tized safety, we’ve de­lib­er­ately tuned the safe­guards to be cau­tious, and they are still stricter than would be ideal—for ex­am­ple, some­times be­nign re­quests will trig­ger our clas­si­fiers. We rec­og­nize that this will be frus­trat­ing to some users, and our aim is to re­duce false pos­i­tives as we up­date and re­fine the safe­guards af­ter launch.

Below we dis­cuss each of Fable 5’s new safe­guards in turn. Our wider suite of safe­guards is dis­cussed and eval­u­ated in the mod­el’s sys­tem card and our most re­cent risk re­port.

Safety clas­si­fiers

The fron­tier cy­ber­se­cu­rity and re­search bi­ol­ogy ca­pa­bil­i­ties of Mythos-class mod­els mean that they pose a sub­stan­tial risk of up­lift to ma­li­cious ac­tors. That is, these mod­els could pro­vide in­for­ma­tion or ad­vice that as­sists those ac­tors in caus­ing se­ri­ous harm that they could­n’t have re­ceived from other sources (for ex­am­ple, from in­ter­net search en­gines). Furthermore, a great deal of ad­vanced us­age of AI mod­els is dual use: the same queries that are ben­e­fi­cial in the hands of cy­ber­se­cu­rity pro­fes­sion­als and bi­ol­ogy re­searchers could be dan­ger­ous if avail­able to ma­li­cious ac­tors.

We there­fore need strong safe­guards to pre­vent mis­use, and their cov­er­age needs to be broad. The safe­guards them­selves have to stand up to sus­tained and so­phis­ti­cated at­tempts to by­pass them (also known as “jailbreaking” the sys­tem). The up­lift from Mythos-level ca­pa­bil­i­ties is valu­able to many ad­ver­saries—for in­stance, those who could fi­nan­cially gain from cy­ber­at­tacks—and we there­fore ex­pect them to be mo­ti­vated to try to cir­cum­vent our safety mea­sures.

Fable 5 comes with a new set of clas­si­fiers: sep­a­rate AI sys­tems that de­tect po­ten­tial mis­use, in­clud­ing jail­break at­tempts, and pre­vent the main model (in this case Fable 5) from re­spond­ing. We’ve been run­ning clas­si­fiers on our mod­els for some time, and Fable 5’s clas­si­fiers are an ex­ten­sion of this pre­vi­ous work with ex­tra cov­er­age.

When Fable’s clas­si­fiers de­tect a re­quest re­lated to cy­ber­se­cu­rity, bi­ol­ogy and chem­istry, or dis­til­la­tion, the re­sponse is au­to­mat­i­cally han­dled by Claude Opus 4.8 in­stead. Users will be in­formed when­ever this oc­curs. Opus 4.8 is a highly ca­pa­ble model in its own right: a re­sponse that falls back to Opus is a far bet­ter ex­pe­ri­ence than an out­right re­fusal from Fable. Our early data shows that more than 95% of Fable ses­sions in­volve no fall­back at all—for those ses­sions, Fable 5’s per­for­mance is ef­fec­tively the same as that of Mythos 5.

The fol­low­ing are the ar­eas cov­ered by the clas­si­fiers:

1. Cybersecurity. Mythos-class mod­els ex­cel at dis­cov­er­ing and ex­ploit­ing soft­ware vul­ner­a­bil­i­ties. They can thus make cy­ber­at­tacks sub­stan­tially eas­ier and cheaper to com­mit. Mythos-class mod­els also show strong skills in agen­tic hack­ing. This in­volves per­form­ing mul­ti­ple dif­fer­ent parts of a cy­ber­at­tack in ad­di­tion to find­ing ex­ploits—re­con­nais­sance, dis­cov­ery, lat­eral move­ment, and more. To pre­vent these agen­tic hack­ing skills pro­vid­ing up­lift in cy­ber­at­tacks, we de­signed our cy­ber­se­cu­rity clas­si­fiers to cover both ex­ploita­tion and of­fen­sive cy­ber tasks in a broader sense. As shown in the graph be­low, our clas­si­fiers pre­vent Fable from mak­ing any progress on these tasks.

We ex­ten­sively red-teamed our clas­si­fiers to test their ro­bust­ness against jail­breaks. As well as in­ter­nal test­ing, we ran an ex­ter­nal bug bounty that pro­duced no uni­ver­sal jail­breaks in over 1,000 hours of test­ing. External red-team­ing or­ga­ni­za­tions we en­gaged also failed to find any uni­ver­sal jail­breaks on long-form agen­tic tasks so far—al­though the UK AISI has made progress to­wards one within a brief ini­tial test­ing win­dow.4 It is likely im­pos­si­ble to com­pletely pre­vent uni­ver­sal jail­breaks, but our goal is to make any re­main­ing jail­breaks suf­fi­ciently slow and costly that we can de­tect and pre­vent them be­fore they are used at scale.

The graph be­low, from one of our in­ter­nal eval­u­a­tions, il­lus­trates how Fable 5’s safe­guards give it greater re­sis­tance to jail­breaks than our pre­vi­ous gen­er­ally ac­ces­si­ble mod­els:

One of our ex­ter­nal part­ners found that Fable 5’s safe­guards against harm­ful cy­ber queries were the most ro­bust of any model tested (including Opus 4.8 and Opus 4.7). Fable 5 com­plied with zero harm­ful sin­gle-turn re­quests re­lat­ing to plan­ning a cy­ber­at­tack, ex­ploit de­vel­op­ment, or de­fense eva­sion. This held whether or not one of the re­quests used any of 30 dif­fer­ent pub­lic jail­break tech­niques.

2. Biology and chem­istry. We have long used our clas­si­fiers to block our mod­els from re­spond­ing on a nar­row se­lec­tion of bioweapons-re­lated queries. But we are no longer cer­tain that block­ing this nar­row se­lec­tion is enough. This is for two rea­sons: first, we have rea­son for con­cern about well-re­sourced ma­li­cious ac­tors at­tempt­ing to gain up­lift from our mod­els for highly risky bi­o­log­i­cal re­search. Second, mod­els now have a greater abil­ity to ac­com­plish real-world sci­en­tific tasks.

For ex­am­ple, we tested Mythos 5’s abil­ity to com­plete a chal­leng­ing step in de­sign­ing adeno-as­so­ci­ated viruses (AAVs). AAVs are a com­po­nent for de­liv­er­ing gene ther­a­pies, but the same ca­pa­bil­ity, in the wrong hands, could en­able the de­sign of dan­ger­ous viruses. In this task, var­i­ous AI mod­els were eval­u­ated on their abil­ity to pre­dict how a ge­netic mod­i­fi­ca­tion would im­pact the as­sem­bly of the virus’s outer shell (among a set of ther­a­peu­ti­cally-rel­e­vant un­pub­lished can­di­dates de­vel­oped by Dyno Therapeutics). We did not ex­plic­itly train our mod­els to per­form this task—and yet Mythos-class mod­els out­per­formed so­phis­ti­cated mod­els ded­i­cated to pro­tein tasks (known as “protein lan­guage mod­els”) us­ing their bi­o­log­i­cal rea­son­ing alone. This demon­strates a promis­ing abil­ity to com­plete sim­ple but im­por­tant tasks in gene ther­apy re­search and de­vel­op­ment—but also high­lights the risk posed by such dual-use ca­pa­bil­i­ties.

Our pri­or­ity was to safely re­lease Fable as soon as we could, even at the cost of overly broad safe­guards. Therefore, for the time be­ing we have arranged for Fable to fall back to Opus 4.8 on most re­quests re­lated to bi­ol­ogy and chem­istry. As with all of our clas­si­fiers, we hope to nar­row these safe­guards as soon as pos­si­ble: as can be seen from the ev­i­dence above, there is great po­ten­tial for pos­i­tive ap­pli­ca­tions of Fable for sci­ence, and we do not want false pos­i­tives from our clas­si­fiers to get in the way. In the com­ing weeks, some bio­med­ical re­searchers and com­pa­nies will be able to join our trusted ac­cess pro­gram for bi­ol­ogy ca­pa­bil­i­ties in Mythos 5 (discussed be­low).

3. Distillation. We’ve pre­vi­ously iden­ti­fied large-scale at­tempts to ex­tract (“distill”) Claude’s ca­pa­bil­i­ties to train com­pet­ing mod­els in au­thor­i­tar­ian coun­tries. Distillation of Fable 5’s abil­i­ties could in­di­rectly lead to the pro­lif­er­a­tion of near-fron­tier AI ca­pa­bil­i­ties—and these could be re­leased with­out the ap­pro­pri­ate safe­guards. Requests that are flagged by our clas­si­fiers as be­ing part of such dis­til­la­tion at­tempts will fall back to Opus 4.8.

A new data re­ten­tion pol­icy

Finally, we’re mak­ing a change to the way we han­dle busi­ness cus­tomer data for Fable 5, Mythos 5, and fu­ture mod­els with sim­i­lar or higher ca­pa­bil­ity lev­els. We will re­quire 30-day re­ten­tion for all traf­fic on Mythos-class mod­els, on both first- and third-party sur­faces. We won’t use this data to train new Claude mod­els, or for any non-safety-re­lated pur­pose, and we’ve in­sti­tuted new pri­vacy pro­tec­tions in­clud­ing log­ging all hu­man ac­cess to the data and en­sur­ing its dele­tion af­ter 30 days in al­most all cases (see this post for fur­ther de­tails). The data will help us de­fend against com­plex and novel at­tacks (including new jail­breaks and at­tacks that op­er­ate across many re­quests) as well as help us iden­tify and re­duce false pos­i­tives.

Claude Mythos 5 and the trusted ac­cess pro­gram

Beginning to­day, all users who cur­rently have ac­cess to Claude Mythos Preview (for ex­am­ple, our cy­ber­se­cu­rity part­ners in Project Glasswing) will be able to up­grade to Claude Mythos 5—the same model as Claude Fable 5 but with cy­ber safe­guards lifted. Users will find Mythos 5 com­pa­ra­ble to, or some­what stronger than, Mythos Preview in most cases, while cost­ing sub­stan­tially less.

In con­sul­ta­tion with the US gov­ern­ment, we plan to steadily ex­pand ac­cess to Claude Mythos 5, con­tin­u­ing our pe­ri­odic ad­di­tion of new part­ners, as well as pur­su­ing a trusted ac­cess pro­gram that al­lows cy­ber­se­cu­rity or­ga­ni­za­tions to ap­ply in a more sys­tem­atic man­ner.

Our plans also in­clude open­ing a trusted ac­cess pro­gram for bi­ol­ogy, to help ac­cel­er­ate bio­med­ical re­search and dis­cover new ther­a­pies with Mythos-class ca­pa­bil­i­ties. This pro­gram will pro­vide ac­cess to Fable 5 with the bi­ol­ogy and chem­istry safe­guards re­moved (but the cy­ber safe­guards still in place). It will en­roll a small num­ber of re­searchers from a va­ri­ety of life sci­ence or­ga­ni­za­tions span­ning fun­da­men­tal and trans­la­tional re­search; we’re plan­ning to ex­pand ac­cess to this pro­gram while si­mul­ta­ne­ously mak­ing our safe­guards bet­ter.

Availability

Claude Fable 5 is avail­able every­where to­day. Claude Mythos 5 is re­stricted to Glasswing part­ners (with cy­ber safe­guards lifted) and soon to se­lect bi­ol­ogy re­searchers (with bi­ol­ogy and chem­istry safe­guards lifted) only, un­til our broader trusted ac­cess pro­gram is avail­able.

Pricing for both mod­els is $10 per mil­lion in­put to­kens and $50 per mil­lion out­put to­kens. Developers can use claude-fa­ble-5 via the Claude API.

We ex­pect de­mand for Fable 5 to be very high, and dif­fi­cult to pre­dict. On the Claude API and con­sump­tion-based Enterprise plans, Fable 5 is fully avail­able from to­day. For sub­scrip­tion plans, we’d rather give ac­cess sooner than later, so we’re rolling out more con­ser­v­a­tively, in stages:

From to­day through June 22, Fable 5 is in­cluded on Pro, Max, Team, and seat-based Enterprise plans at no ex­tra cost.

On June 23, we’ll re­move Fable 5 from those plans. Using it af­ter that will re­quire us­age cred­its. If ca­pac­ity al­lows, we’ll ex­tend the in­cluded win­dow.

After this point—when suf­fi­cient ca­pac­ity al­lows us to do so—we aim to re­store Fable 5 as a stan­dard part of sub­scrip­tion plans. We in­tend to do this as quickly as we can.

Throughout this pe­riod, we’ll com­mu­ni­cate any changes ahead of time so users know where things stand.

Edit June 9, 2026: Updated the dis­cus­sion of AAVs to note that the can­di­dates were de­vel­oped by Dyno Therapeutics.

Related con­tent

Introducing the Services Track and Partner Hub of the Claude Partner Network

Read more

What we learned map­ping a year’s worth of AI-enabled cy­ber threats

As AI trans­forms the na­ture of and meth­ods be­hind cy­ber­at­tacks, how well do the tech­niques and frame­works used by the se­cu­rity com­mu­nity hold up? In a new re­port, we seek to an­swer that ques­tion.

Read more

Expanding Project Glasswing

We’re ex­tend­ing Project Glasswing to ap­prox­i­mately 150 new or­ga­ni­za­tions in more than fif­teen coun­tries.

Read more

Catlantean 3D is a side-pro­ject I’ve been slowly build­ing in my spare time for over a year, and I in­tend to re­lease it on Steam next year.

My goal was to build a com­plete, ship­pable first-per­son shooter us­ing tech­niques that were com­mon in the early 90s, while al­low­ing my­self the lux­ury of us­ing a mod­ern com­piler and a plat­form ab­strac­tion layer.

What this ac­tu­ally means is, the con­straints I have fool­ishly im­posed upon my­self are as fol­lows:

game must be made en­tirely from scratch, in­clud­ing the as­sets

all ren­der­ing must be done by hand

all sound mix­ing must be done by hand

320x240 tar­get res­o­lu­tion

256 col­ors only

float­ing point al­lowed, but be­hav­ior must be con­sis­tent across plat­forms de­cided on fixed point for game logic to guar­an­tee de­ter­min­is­tic be­hav­ior, float­ing point for ren­der­ing be­cause de­ter­min­ism is­n’t that im­por­tant there

de­cided on fixed point for game logic to guar­an­tee de­ter­min­is­tic be­hav­ior, float­ing point for ren­der­ing be­cause de­ter­min­ism is­n’t that im­por­tant there

must be a fin­ished, pol­ished game that is fun to play (not a tech-demo)

plat­form ab­strac­tion layer al­lowed, but I must pre­tend it’s very lim­ited (within rea­son): frame buffer to write pix­els into key­board/​mouse in­put au­dio buffer to write sam­ples into filesys­tem I/O

frame buffer to write pix­els into

key­board/​mouse in­put

au­dio buffer to write sam­ples into

filesys­tem I/O

no AI slop

If this sounds un­rea­son­able to you, that is be­cause it is.

But I’m do­ing it any­way, and to­day I’m gonna talk about some­thing that is typ­i­cally over­looked in de­vel­op­ment blogs, and that is as­set cre­ation.

Note: Everything dis­played here is work-in-progress, and heav­ily sub­ject to change.

Table of Contents

Palette Rendering

VGA Graphics The Palette The Colormap

VGA Graphics

The Palette

The Colormap

Creating Assets

Pre-rendered Sprites Hand-drawn Sprites and Textures Procedurally Generated Sprites and Textures

Pre-rendered Sprites

Hand-drawn Sprites and Textures

Procedurally Generated Sprites and Textures

Maps

Conclusion

Changelog

2026 – 06-09 - pub­lished.

Palette Rendering

VGA Graphics

Mode 13h on VGA hard­ware was the fa­mous 320x200 256-color graph­ics mode that de­fined a gen­er­a­tion of PC games. From a pro­gram­mer’s per­spec­tive it was won­der­fully sim­ple: you’d have a lin­ear frame buffer where each pixel was rep­re­sented by a sin­gle byte in­dex­ing into a palette of 256 col­ors.

If you wanted to draw a pixel, you wrote a byte at a spe­cific ad­dress, and that was it, there were no shaders or VRAM, or any­thing like that.

One byte per pixel, and that byte is an in­dex into a palette which con­tains ac­tual RGB val­ues that would be ren­dered to screen. This im­poses some in­ter­est­ing lim­i­ta­tions; when mak­ing as­sets for mod­ern games, you can throw mil­lions of col­ors at an im­age, but when your lim­i­ta­tion is that every pixel on screen can only be one of 256 col­ors, as­set cre­ation be­comes a very dif­fer­ent prob­lem be­cause every color choice has to be care­ful and de­lib­er­ate.

Games like Doom and Duke Nukem are good ex­am­ples of this done right. There is a cer­tain crispi­ness and clar­ity to these graph­ics that arises be­cause of these tech­ni­cal lim­i­ta­tions, not in spite of them. Restriction forces de­lib­er­ate choices, and de­lib­er­ate choices tend to look good.

Catlantean 3D is an at­tempt to re­pro­duce that feel­ing, but with one caveat - I’m ac­tu­ally go­ing for some­thing closer to VGA Mode-X, which is 320x240. The rea­son for this is, if you dis­play 320x200 on a 4:3 dis­play, you end up with non-square pix­els! While this would be most au­then­tic, I’ve cho­sen not to deal with this out of pref­er­ence rather than ob­jec­tive rea­son.

So how does one cre­ate graph­ics that work within these lim­its?

The Palette

Everything be­gins with 768 bytes, care­fully picked through many it­er­a­tions of trial and er­ror.

The main rea­son­ing for pick­ing these ex­act col­ors was the fol­low­ing:

one re­served for trans­parency (the vi­brant pink)

one re­served for pure white

one re­served for pure black

I was ob­vi­ously go­ing to need a lot of blood, thus reds

shades of green and blue be­cause I was go­ing to have red, green and blue keys and color-coded doors

game would be set in Catlantis, which is a par­ody land that re­sem­bles an­cient Egypt (because cat wor­ship), so ob­vi­ously, a lot of desert hues (yellows and browns)

lots of grays be­cause the set­ting in­volves many tech­ni­cal in­stal­la­tions (Catlantis is un­der oc­cu­pa­tion by cy­ber­netic dog-men)

some beige hues to break up mo­not­ony over grays, and to serve as warmer re­place­ments when dark­en­ing (more on this later)

the rest would be filled as nec­es­sary when cre­at­ing tex­tures - highly sub­jec­tive and im­pos­si­ble to ex­plain, other than “it looked right”

The palette did not spring into life all at once; it in­volved a lot of back-and-forth dur­ing as­set cre­ation, test­ing, and re-it­er­at­ing in gen­eral.

Below are some ex­am­ples of sprites and tex­tures from the ac­tual game:

The Colormap

Catlantean 3D is a tra­di­tional ray­caster. The map con­sists of tiles which are all iden­ti­cal in size; some are walls, oth­ers are just voids with a floor and ceil­ing. In or­der to ren­der the map, the ren­derer uses the DDA al­go­rithm for each col­umn of screen, tra­vers­ing the tilemap and de­ter­min­ing where it hits the map geom­e­try, and based on this, a wall col­umn is ren­dered on screen with the ap­pro­pri­ate tex­ture, sam­pled from ap­pro­pri­ate co­or­di­nates. Floors and ceil­ings are ren­dered af­ter as hor­i­zon­tal scan­lines, fill­ing in the rest of the screen.

Raycasting has been done to death by other blogs and web­sites, so I’m not go­ing to cover all of it, but I do want to cover what I think is its most over­looked as­pect: light­ing.

If we were to ren­der the game world us­ing just the palette, with­out any spe­cial ef­fects, we would end up with some­thing that looked rather flat and unim­pres­sive:

But what we wanted was the fol­low­ing. Notice how the light di­min­ishes the fur­ther away geom­e­try is from player, and how one side of the map tiles is just slightly darker than the other. This gives an im­pres­sion of depth.

With a mod­ern hard­ware-ac­cel­er­ated ren­derer, this would be triv­ially done in a shader - based on how far the ver­tex is, we would mul­ti­ply its color vec­tor by a float­ing point fac­tor and get a di­min­ished color vec­tor as a re­sult.

But how do we achieve some­thing like this with a palette ren­derer? It has no con­cept of color, just in­dices into palette. So if we wanted to find a darker shade of a cer­tain color, we would need to loop through the palette and find the color that meets our cri­te­ria of “darker”. This is just too much be­cause we can’t loop through the en­tire palette for every pixel we ren­der onto the screen, it would be too slow.

What we could do in­stead was some pre­pro­cess­ing, to al­low a fast color lookup based on dis­tance at run­time.

If we were to lay out our palette into a sin­gle row like this…

We then choose the num­ber of shade lev­els (32 in my case) mean­ing each color needs 31 darker vari­ants, all sourced from the palette. We know each col­or’s RGB val­ues, so from this, and the shade in­dex we can de­ter­mine the clos­est tar­get color of that shade:

// First shade in­dex (0) is orig­i­nal color. float dark­en­ing_­fac­tor = (32 - shade_in­dex) / 32.0f; tar­get_­dark­er_­color.r = cur­ren­t_­color.r * dark­en­ing_­fac­tor; tar­get_­dark­er_­color.g = cur­ren­t_­color.g * dark­en­ing_­fac­tor; tar­get_­dark­er_­color.b = cur­ren­t_­color.b * dark­en­ing_­fac­tor;

But that color might not ex­ist in the palette. So we need to loop through the palette and find the clos­est color to it.

Definition of “close” ac­tu­ally changed for me dur­ing de­vel­op­ment - at first, I just took eu­clid­ean dis­tance as a mea­sure, but the prob­lem with that was that al­most every­thing had a ten­dency to grav­i­tate to­wards the greys, sim­ply due to the math­e­mat­ics. Some older games ac­tu­ally did use Euclidean dis­tance, but to me this did­n’t look very good. I can’t ex­plain why ex­actly, but a lot of darker shades ap­peared some­what cold and life­less. So in­stead, I con­verted my col­ors to Oklab color space, and lever­aged its per­cep­tual dis­tance for­mula, which is closer to how hu­mans per­ceive color dif­fer­ences. I also ap­ply a small shift to­wards warmer hues the darker the color is (a com­mon con­cept in pixel art called “hue shift­ing”). This is typ­i­cally not nec­es­sary, but it does make the game look just a bit bet­ter.

How do I de­fine “better” in this case? I have no idea, it just looks right. Frustrating, is­n’t it? It’s hard to ra­tio­nal­ize some­thing sub­jec­tive.

Back to our al­go­rithm…

Essentially, for each color, we cre­ate a col­umn that rep­re­sents the shades of that color. What we end up with is a 2D ma­trix of palette in­dices called the col­ormap. Note that the col­ormap gra­di­ents are im­per­fect, be­cause we’re still re­stricted to col­ors from the palette:

So now, de­ter­min­ing a darker shade of color N based on dis­tance be­comes triv­ial.

Given col­ormap row in­dex (i.e. shade level) based on dis­tance:

col­ormap_row = 32 * frag­men­t_dis­tance / view_dis­tance

We pick N-th en­try in row be­long­ing to that shade - that is the palette in­dex of the dark­ened color N.

And voila, O(1).

Also, in­stead of cal­cu­lat­ing the col­ormap row in­dex for every pixel, the cost is fur­ther re­duced by per­form­ing cal­cu­la­tion:

only once per screen col­umn when ren­der­ing walls, be­cause they’re per­fectly ver­ti­cal, so every pixel in col­umn has same dis­tance from cam­era

only once per screen row when ren­der­ing floors, be­cause they’re per­fectly hor­i­zon­tal, so every pixel in row has same dis­tance from cam­era

only once per sprite be­cause they are per­fectly flat bill­boards where every pixel has the same dis­tance from cam­era

So we’re do­ing col­ormap row in­dex cal­cu­la­tion 320 times for walls, at most 240 times for floors, and once per vis­i­ble sprite (raycasting gives free oc­clu­sion culling). That is cheap, and the pay­off is great.

Doom and many other ti­tles used sim­i­lar ap­proaches.

Creating Assets

Textures and sprites in Catlantean 3D fall into three cat­e­gories:

Pre-rendered sprites - 3D mod­els cre­ated in Blender and ren­dered to tex­tures

Hand-drawn sprites and tex­tures

Procedurally gen­er­ated tex­tures - gen­er­ated via spe­cial Python scripts by com­bin­ing hand-drawn art

Pre-rendered Sprites

I am work­ing a full-time job and have a de­cently ac­tive life, so my time to work on the game is lim­ited. Thus, I wanted to min­i­mize the time I spend re­it­er­at­ing when mak­ing com­plex sprites that in­volve an­i­ma­tions. I rarely get some­thing right on the first at­tempt, so nat­u­rally, re­it­er­a­tion is ex­pected, and it is hard to re­it­er­ate when you need to make changes to many frames of an an­i­ma­tion.

The more ef­fi­cient ap­proach was to cre­ate sprites in Blender as 3D mod­els, rig and an­i­mate them there, and then ren­der them to a se­ries of tex­tures with spe­cial Python scripts that lever­age Blender’s Python API. Reiteration then in­volved mak­ing changes in the model, and the ren­der­ing scripts did the rest, which was a lot of time saved.

The main hur­dle was that ren­dered sprites came out very blurry and washed out.

One might think that the ob­vi­ous an­swer to this was to ren­der the sprite in high res­o­lu­tion, and then down­scale with fil­ter­ing, but I’ve had mixed suc­cess with this; de­tails would of­ten be sup­pressed by fil­ter­ing, and edge clar­ity would be lost. What I found to be the most ef­fec­tive and reusable was to lever­age Blender’s com­posit­ing func­tion­al­ity to get the right amount of con­trast and clar­ity:

Once the im­age was ready, it would be sent through a spe­cial Python script which per­formed palette quan­ti­za­tion, cre­at­ing a 1-byte-per-pixel im­age used by the en­gine. For every pixel in the source im­age, the script finds the clos­est color in our palette (perceptually clos­est - Oklab), and uses the in­dex of that color for that pixel. The in­dex ar­ray, along with the di­men­sions, is then packed into the very sim­ple TEX for­mat that is used by the game.

A sim­i­lar work­flow was used for en­emy sprites. Note: some of these nodes are ei­ther re­dun­dant, or plain use­less, sim­ply be­cause I had used them at some point, and then changed my mind. I like leav­ing them in just in case I need them again.

Enemy sprites are ren­dered in a spe­cial way. Sprite can have mul­ti­ple an­i­ma­tions, and each an­i­ma­tion must have frames for each of the 8 di­rec­tions sprite can face. So, for every an­i­ma­tion (walk, fire, die, etc.), the Python script that uses Blender’s API ro­tates the sprite, ren­ders all frames of an an­i­ma­tion, ro­tates the sprite again, and so on. Sprites are saved with a spe­cial con­ven­tion that de­notes sprite name, ac­tion name, di­rec­tion and frame in­dex:

Nice thing about this ap­proach is that I don’t need to keep ren­dered sprites in the repos­i­tory - they’re ac­tu­ally .gitignored. Whenever I switch lo­ca­tions and use an­other com­puter, I sim­ply run the com­pi­la­tion script which ren­ders every model and pro­duces the sprites. It is rea­son­ably fast and runs in ~10 sec­onds for about 15 mod­els on RTX 3070.

Hand-drawn Sprites and Textures

Earlier in de­vel­op­ment, I cre­ated this vaguely cat-shaped head with the tex­ture of my cat Vilko, to use as a sta­tus bar face. After all, why would I draw some­thing like this by hand, if Blender could ren­der it in such a vivid like­ness of life?

GitHub

Wiki

Docs

OpenCV 5 is one of the most im­por­tant re­leases in the his­tory of OpenCV.

For more than two decades, OpenCV has been the foun­da­tion for com­puter vi­sion re­search, ro­bot­ics, em­bed­ded vi­sion, AI ap­pli­ca­tions, in­dus­trial in­spec­tion, AR/VR, med­ical imag­ing, and count­less pro­duc­tion sys­tems. Today, the li­brary has more than 86,000 GitHub stars, more than a mil­lion in­stalls per day, and one of the largest col­lec­tions of com­puter vi­sion al­go­rithms in the world.

OpenCV 5 builds on that foun­da­tion with a ma­jor mod­ern­iza­tion of the li­brary. It brings a new DNN en­gine, stronger ONNX sup­port, hard­ware ac­cel­er­a­tion im­prove­ments, bet­ter Python in­te­gra­tion, new data types, ex­panded 3D vi­sion ca­pa­bil­i­ties, im­proved doc­u­men­ta­tion, and a cleaner ar­chi­tec­ture for the fu­ture.

This is not just an­other in­cre­men­tal re­lease. OpenCV 5 is a ma­jor step for­ward.

Why OpenCV 5

Computer vi­sion has changed dra­mat­i­cally since OpenCV 4.

Modern ap­pli­ca­tions now com­bine clas­si­cal vi­sion, deep learn­ing, trans­form­ers, large vi­sion mod­els, edge de­ploy­ment, het­ero­ge­neous hard­ware, and Python-first work­flows. Developers ex­pect the same code to run ef­fi­ciently across lap­tops, servers, em­bed­ded de­vices, ARM chips, Snapdragon plat­forms, and spe­cial­ized ac­cel­er­a­tors.

OpenCV 5 was de­signed to meet that re­al­ity.

The goals were clear: make the core faster and smaller, im­prove lan­guage sup­port, clean up old APIs, mod­ern­ize the DNN en­gine, sup­port new hard­ware ac­cel­er­a­tion paths, im­prove 3D vi­sion tool­ing, and make the doc­u­men­ta­tion eas­ier to use.

If you have shipped any­thing with OpenCV in the last few years, you know the feel­ing. The li­brary does al­most every­thing, but the deep learn­ing side al­ways felt a step be­hind the mod­els peo­ple were re­ally us­ing. You would ex­port a new model to ONNX, point OpenCV’s DNN mod­ule at it, and cross your fin­gers. Sometimes it worked. Sometimes it threw an er­ror about an op­er­a­tor it had never heard of.

In this post we will walk through what is new, why it mat­ters in prac­tice, and what it changes for the code you write. You do not need to know the li­brary’s in­ter­nals. If you have ever writ­ten cv2.im­read, you are in the right place.

The pip ver­sion of OpenCV5 will be re­leased on 8th June.

Table of con­tents

Why OpenCV 5

Where OpenCV Stands Today

What OpenCV 5 Set Out to Fix

The Headline: A Brand-New DNN Engine

Three Engines, One API

How Fast Is It? OpenCV 5 vs ONNX Runtime

Models That Run Out of the Box

LLMs and VLMs, Running Inside OpenCV

Inpainting and Diffusion with LaMa

Modern Feature Matching, the Deep Learning Way

A Faster, Leaner, More Modern Core

Hardware Acceleration You Get for Free

Better 3D Vision

Documentation That Doesn’t Fight You

What OpenCV 5.0 Ships With

What’s Next: GPU in the DNN Engine and a Non-CPU HALNative GPU sup­port in the new DNN en­gineA non-CPU HAL for ac­cel­er­ated pre- and post-pro­cess­ing

Native GPU sup­port in the new DNN en­gine

A non-CPU HAL for ac­cel­er­ated pre- and post-pro­cess­ing

Try It and Get Involved

Conclusion

Where OpenCV Stands Today

Before we get into what changed, it helps to re­mem­ber how widely used OpenCV is. This is not a niche re­search tool. It is plumb­ing for a huge slice of the com­puter vi­sion world.

When a li­brary is this deeply em­bed­ded in pro­duc­tion sys­tems, every change has to be made care­fully. That is part of why a ma­jor ver­sion takes time, and why it is a big deal when one fi­nally ar­rives.

It also helps to know who builds it. OpenCV is stew­arded by the non-profit OpenCV.org, with de­vel­op­ment and sup­port com­ing from Big Vision (which sup­ports the li­brary, OpenCV University, and con­tent like this blog), OpenCV China (a ma­jor force be­hind RISC-V and em­bed­ded work) and OpenCV.ai.

What OpenCV 5 Set Out to Fix

The team started OpenCV 5 with a clear list of pain points. If you have used OpenCV for a while, you will rec­og­nize most of them:

Better lan­guage sup­port: mod­ern Python, re­freshed bind­ings, and named ar­gu­ments in­stead of guess­ing pa­ra­me­ter or­der.

A faster, smaller core: tighter code, the legacy C API re­tired, and leaner builds.

A cleaner hard­ware ac­cel­er­a­tion layer, so ven­dors can plug in op­ti­mized ker­nels with­out a tan­gle of #ifdefs.

A cleaner API: proper 0D/1D ten­sors, na­tive FP16/BF16, and real log­ging.

A next-gen­er­a­tion DNN en­gine: graph-based, with fu­sions, broad ONNX sup­port, trans­form­ers, and VLM/LLMs.

Better 3D vi­sion: ChArUco, multi-cam­era cal­i­bra­tion, and vi­su­al­iza­tion.

Better doc­u­men­ta­tion: mod­ern, nav­i­ga­ble, and pleas­ant to read.

The rest of this post is that list, made real. We will start with the change that af­fects the most peo­ple.

The Headline: A Brand-New DNN Engine

The sin­gle most im­por­tant num­ber in this re­lease is cov­er­age. OpenCV’s ONNX op­er­a­tor sup­port jumped from roughly 22% in the 4.x days to over 80% in OpenCV 5.

If you have ever fought with OpenCV re­fus­ing to load a mod­ern model, that num­ber is the fix. The rea­son be­hind it is more in­ter­est­ing than the num­ber it­self.

The old 4.x en­gine im­ported a small frac­tion of the ONNX op­er­a­tor set and strug­gled with any­thing that had dy­namic shapes, which cov­ers most in­ter­est­ing mod­els these days. The 5.x en­gine was re­built around a typed op­er­a­tion graph with proper shape in­fer­ence, con­stant fold­ing, and op­er­a­tor fu­sion. Instead of treat­ing a net­work as a flat list of lay­ers and walk­ing them one by one, OpenCV 5 un­der­stands the model as a graph. That lets it rea­son about the net­work, sim­plify it, and run it far more ef­fi­ciently.

A few things the new en­gine han­dles that the old one could not:

If and Loop sub­graphs: mod­els with con­trol flow now load and run.

Symbolic and dy­namic shapes: no more brit­tle “shapes must be known ahead of time.”

Quantize/Dequantize (QDQ) graphs: for run­ning quan­tized mod­els.

Attention and MatMul fu­sions: the build­ing blocks of trans­form­ers, col­lapsed into ef­fi­cient fused op­er­a­tions.

That last point de­serves a closer look. One of the head­line op­ti­miza­tions is at­ten­tion fu­sion. The en­gine rec­og­nizes the clas­sic MatMul → Softmax → MatMul pat­tern at the heart of every trans­former and col­lapses it into a sin­gle fused at­ten­tion op­er­a­tion, backed by a FlashAttention-style im­ple­men­ta­tion. You get this for free. Load your model, and it runs faster.

The prac­ti­cal re­sult is straight­for­ward. More mod­els load, more mod­els run cor­rectly, and many of them run faster.

Three Engines, One API

Rewrites make peo­ple ner­vous, and rightly so. Nobody wants a work­ing pipeline to break on up­grade day. OpenCV 5 han­dles this by keep­ing more than one en­gine avail­able be­hind the same DNN API. You choose which one loads your model right where you read it, through an en­gine ar­gu­ment on the read­Net* fam­ily of func­tions. The val­ues come from the cv::dnn::En­gine­Type enum:

Because ENGINE_AUTO is the de­fault, most code does not have to do any­thing spe­cial. You read the model, and OpenCV uses the new en­gine when it can and the old one when it can­not. When you want to pin a spe­cific en­gine, you pass it at load time.

Python

im­port cv2 as cv

# Default be­hav­iour (ENGINE_AUTO): new en­gine first, clas­sic as fall­back. net = cv.dnn.read­Net­FromONNX(“model.onnx”)

# Or pin the new graph en­gine ex­plic­itly. “”″ net = cv.dnn.read­Net­FromONNX(“model.onnx”, en­gine=cv.dnn.EN­GINE_NEW) “”″ net.set­Input(blob) out = net.for­ward()

cpp

#include <opencv2/dnn.hpp> us­ing name­space cv;

// Default be­hav­iour (ENGINE_AUTO). dnn::Net net = dnn::read­Net­FromONNX(“model.onnx”);

// Or pin a spe­cific en­gine at load time. /* dnn::Net net­New = dnn::read­Net­FromONNX(“model.onnx”, dnn::EN­GINE_NEW); */ net.set­Input(blob); Mat out = net.for­ward();

One prac­ti­cal de­tail is worth know­ing. The new en­gine is CPU-only at the mo­ment, so if you se­lect a non-CPU back­end and tar­get (for ex­am­ple CUDA or OpenVINO through set­Prefer­able­Back­end and set­Prefer­able­Tar­get), you will want the clas­sic en­gine.

The OpenCV sam­ples han­dle this for you by switch­ing to ENGINE_CLASSIC when you pass a non-de­fault back­end or tar­get on the com­mand line.

This de­sign keeps up­grade-day risk low. The old en­gine is still there for any­thing the new one can­not load yet or can­not ac­cel­er­ate, and the op­tional ONNX Runtime path (when built in) widens cov­er­age fur­ther, all through the same Net API.

How Fast Is It? OpenCV 5 vs ONNX Runtime

Coverage is one thing, and speed is what peo­ple ar­gue about. The team bench­marked the new en­gine head-to-head against ONNX Runtime on CPU across a range of real mod­els. Here are the cases where OpenCV 5 comes out ahead:

Hardware: Intel Core i9 – 14900KS, Ubuntu 24.04 LTS. Lower la­tency is bet­ter. The dif­fer­ence is how much faster OpenCV 5 DNN is than ONNX Runtime on the same model and ma­chine.

The pat­tern holds across the board. From tiny real-time de­tec­tors like YOLO26n to heavy­weight open-vo­cab­u­lary mod­els like OWLv2, OpenCV 5’s na­tive en­gine is com­pet­i­tive with, and of­ten faster than, a ma­ture and heav­ily op­ti­mized run­time, all while keep­ing every­thing in­side a sin­gle de­pen­dency. A com­pre­hen­sive bench­mark can be found at OpenCV5 DNN Benchmark.

Models That Run Out of the Box

Better ONNX cov­er­age stays ab­stract un­til you see the list of mod­els it un­locks. OpenCV 5 has been val­i­dated against a broad, mod­ern lineup span­ning de­tec­tion, seg­men­ta­tion, back­bones, and gen­er­a­tive mod­els:

If your pro­ject de­pends on any of these, OpenCV 5 means one fewer frame­work in your de­pen­dency list.

LLMs and VLMs, Running Inside OpenCV

This one still sur­prises peo­ple. OpenCV 5 can run large lan­guage mod­els and vi­sion-lan­guage mod­els di­rectly in­side the DNN mod­ule, with no sep­a­rate run­time.

To make that work, OpenCV 5 ships two things that clas­sic CV li­braries never needed:

a na­tive to­k­enizer, built into the li­brary, and

a KV-cache for au­tore­gres­sive de­cod­ing, so gen­er­a­tion stays ef­fi­cient as the model pro­duces to­kens one at a time.

These work across Qwen 2.5, Gemma 3, PaliGemma, and the GPT-2 / GPT-4 fam­ily, all through the same Net API you al­ready use for a YOLO model. Vision-language pipelines (image in, text out) are sup­ported through mod­els like PaliGemma.

In the team’s tests, ask­ing Qwen 2.5 “What is OpenCV?” through OpenCV’s en­gine pro­duced out­put that matched ONNX Runtime to­ken for to­ken. That is a re­as­sur­ing sign that cor­rect­ness was not traded away for the con­ve­nience of keep­ing every­thing in one li­brary.

Will OpenCV re­place a ded­i­cated LLM serv­ing stack for a pro­duc­tion chat­bot? No, and it does not aim to. What it gives you is a vi­sion pipeline that can reach for a small lan­guage or vi­sion-lan­guage model for tasks like cap­tion­ing, OCR post-pro­cess­ing, or open-vo­cab­u­lary queries, with­out bolt­ing on a whole sep­a­rate frame­work.

Inpainting and Diffusion with LaMa

One of the most sat­is­fy­ing demos in the re­lease is ob­ject re­moval with LaMa, run­ning en­tirely in­side the new DNN en­gine. You give it an im­age and a mask of what to re­move, and it fills the hole back in with blended edges and no ex­ter­nal run­time.

The flow is as sim­ple as it sounds:

Input im­age: the photo with some­thing you want gone.

Mask: the re­gion to re­move, ei­ther drawn by a user or pro­duced by a de­tec­tor.

One for­ward pass: a sin­gle Net::forward through the OpenCV DNN en­gine.

Clean out­put: the hole filled and the edges blended.

And the code re­ally is this short:

im­port cv2 as cv

net = cv.dnn.read­Net­FromONNX(“lama.onnx”) blob = cv.dnn.blobFromIm­ages([img, mask], scale­fac­tor=1/​255.) net.set­Input(blob) out = net.for­ward() # in­painted im­age

Microsoft has cut off ac­cess to dozens of its open source pro­jects hosted on GitHub as it in­ves­ti­gates how hack­ers ap­par­ently breached the pro­jects and in­jected pass­word-steal­ing mal­ware into the code.

Many of the af­fected pro­jects re­late to Microsoft’s cloud ser­vice Azure and other tools used by de­vel­op­ers to code with AI de­vel­op­ment apps, such as Claude Code, Gemini’s com­mand line in­ter­face, and VS Code.

According to se­cu­rity firm Cloudsmith and com­mu­nity-dri­ven mal­ware analy­sis site OpenSourceMalware, which were some of the first to flag the hack, the mal­ware al­lowed the hack­ers to steal the users’ pass­words and other sen­si­tive cre­den­tials when they opened the com­pro­mised tools in their AI cod­ing apps.

It’s not im­me­di­ately known how many peo­ple have down­loaded the af­fected tools.

Microsoft con­firmed it pulled the re­pos, as first re­ported by 404 Media.

Microsoft spokesper­son Ben Hope told TechCrunch that the com­pany has “temporarily re­moved some repos­i­to­ries as we in­ves­ti­gated po­ten­tial ma­li­cious con­tent.”

“Some of these re­pos have been re­stored af­ter re­view, while oth­ers may re­main of­fline while work con­tin­ues.”

“As part of our in­ves­ti­ga­tion, we no­ti­fied a small num­ber of cus­tomers who may have pulled down con­tent from the af­fected repos­i­to­ries. We will con­tinue to in­ves­ti­gate, and if any­thing fur­ther is iden­ti­fied that re­quires cus­tomer ac­tion, we will reach out di­rectly through our es­tab­lished sup­port chan­nels,” added Hope.

Microsoft did not im­me­di­ately pro­vide the spe­cific num­ber of cus­tomers af­fected, when asked by TechCrunch.

At least 70 pro­jects be­long­ing to Microsoft have been “disabled,” per a mes­sage load­ing when try­ing to ac­cess the pro­jects’ pages on GitHub, a code-host­ing site that Microsoft owns. “Access to this repos­i­tory has been dis­abled by GitHub Staff due to a vi­o­la­tion of GitHub’s terms of ser­vice.”

This is the lat­est ex­am­ple in re­cent months of hack­ers breach­ing widely pop­u­lar open source pro­jects with the aim of plant­ing mal­ware on a large num­ber of users who have the code in­stalled on their com­put­ers. These hacks are known as “supply chain” at­tacks as they tar­get code that is of­ten used in a large num­ber of soft­ware prod­ucts, or by a spe­cific kind of user, which may be ad­van­ta­geous to hack as they some­times have ac­cess to cloud sys­tems and large amounts of cus­tomers’ data.

While it’s not un­com­mon for sole de­vel­op­ers of open source pro­jects to be tar­geted by hack­ers — in some cases as part of long-run­ning ef­forts to gain the trust of the de­vel­oper — it is rare for large tech gi­ants like Microsoft, which have the re­sources to de­fend against these kinds of at­tacks, to get breached.

This is Microsoft’s sec­ond known breach over the past few weeks that has al­lowed hack­ers to com­pro­mise its open source pro­jects, per Ars Technica. In mid-May, se­cu­rity re­searchers said that Microsoft’s open source pro­ject Durable Task, a tool that helps de­vel­op­ers build apps, was hacked. OpenSourceMalware said that Microsoft’s lat­est in­ci­dent is a “re-compromise” of the Durable Task pro­ject, sug­gest­ing that Microsoft may not have erad­i­cated the hack­ers on its first at­tempt or an en­tirely new, dis­tinct breach.

Updated with com­ment from Microsoft.

When you pur­chase through links in our ar­ti­cles, we may earn a small com­mis­sion. This does­n’t af­fect our ed­i­to­r­ial in­de­pen­dence.

Zack Whittaker is the se­cu­rity ed­i­tor at TechCrunch. He also au­thors the weekly cy­ber­se­cu­rity newslet­ter, this week in se­cu­rity.

He can be reached via en­crypted mes­sage at za­ck­whit­taker.1337 on Signal. You can also con­tact him by email, or to ver­ify out­reach, at zack.whit­taker@techcrunch.com.

View Bio

Albania’s “Flamingo Revolution” is test­ing how far a gov­ern­ment will go to pro­tect a for­eign in­vestor’s in­ter­ests, and whether the EU will hold it ac­count­able.

Albanian anti-cor­rup­tion pros­e­cu­tors froze the bank ac­counts of Albania Land Development, the com­pany that bought beach­front plots for a lux­ury re­sort backed by Jared Kushner, as na­tional protests against the pro­ject en­tered their sev­enth con­sec­u­tive day. The pre­ven­tive seizure was or­dered by SPAK, the Special Prosecution Against Corruption and Organised Crime, as part of a prop­erty-fraud in­ves­ti­ga­tion into how land ti­tles in a pro­tected coastal wet­land were ac­quired and how the area was stripped of its pro­tected sta­tus. Albania Land Development is owned by the Syrian, na­tion­al­ized Qatari broth­ers Moutaz and Ramez Al-Khayyat, who re­cently bought the plots in Zvernec, near the south­ern city of Vlora. One source put the frozen sum at about $195 mil­lion trans­ferred for the land, a fig­ure SPAK has not con­firmed.

SPAK con­firmed on 2 June that it had opened a case into the changes made in 2024 to the pro­tected sta­tus of the Vjosa-Narta area and into how own­er­ship of the land was ob­tained. Prosecutors said they would also ex­am­ine how of­fi­cials by­passed the nor­mal pub­lic-ten­der sys­tem and the ori­gin of the funds used to buy the land ti­tles, in an area where own­er­ship has been dis­puted since the col­lapse of com­mu­nism in the 1990s. In 2024, the Albanian Parliament passed spe­cial leg­is­la­tion re­clas­si­fy­ing Sazan and the Pishe Poro-Narta area to per­mit large-scale de­vel­op­ment, the move that made the strate­gic in­vestor des­ig­na­tion pos­si­ble; op­po­si­tion par­ties and en­vi­ron­men­tal groups ar­gued the changes were writ­ten to ac­com­mo­date Kushner-linked in­vestors. One ad­min­is­tra­tor of Albania Land Development, Redi Struga, has re­port­edly been sub­ject to searches.

Rama has tried to oc­cupy both sides of the SPAK ac­tion, back­ing the in­ves­ti­ga­tion into the sus­pi­cious lo­cal sell­ers while de­fend­ing the for­eign in­vestors as le­git­i­mate. He con­demned the guards’ con­duct as “disgusting” and told par­lia­ment he wanted to make Albania “a des­ti­na­tion to be en­vied in the re­gion,” in­sist­ing the fi­nal pro­posal had not been sub­mit­ted, the en­vi­ron­men­tal study was in­com­plete, and the la­goon it­self would not be touched. He said five in­ter­na­tional ar­chi­tec­ture firms were re­design­ing the mas­ter­plan.

“The in­vestors are within their rights. Blocking the trans­ac­tion is ar­bi­trary and neg­a­tive,” Rama told re­porters.

He has re­fused to halt the wider plan. In an in­ter­view with Politico at the EU-Western Balkans sum­mit in Tivat, Montenegro, he said the protests would never have gath­ered this much at­ten­tion on their own.

“If it was not Jared, they would not give a shit about what is hap­pen­ing in Albania,” Rama said.

Rama, a long-time friend of the Trump and Kushner fam­i­lies, claimed the anti-cor­rup­tion and land de­fence cam­paign was be­ing pushed by op­po­nents of Donald Trump.

The protests, which civil so­ci­ety and in­ter­na­tional me­dia have called the Flamingo Revolution, have grown well past their en­vi­ron­men­tal start­ing point into a chal­lenge to Rama him­self, and the as­set freeze is only the most vis­i­ble of sev­eral le­gal and diplo­matic pres­sures now bear­ing on his gov­ern­ment.

Two pro­jects, one coast­line

The de­vel­op­ment is two ven­tures pre­sented as one am­bi­tion. Off the bay of Vlora sits Sazan, Albania’s largest is­land at about 5.7 square kilo­me­tres, a for­mer Italian and then com­mu­nist-era mil­i­tary base kept off-lim­its for decades and cov­ered in Cold War bunkers and tun­nels. On 30 December 2024, a Strategic Investment Committee chaired by Rama granted strate­gic in­vestor sta­tus to Atlantic Incubation Partners, a firm af­fil­i­ated with Kushner’s Affinity Partners, for an Aman-branded eco-re­sort on the is­land, a pro­ject val­ued at about 1.4 bil­lion eu­ros and pro­jected to em­ploy roughly 1,000 peo­ple. Reuters, which saw the writ­ten de­ci­sion, re­ported that the state would take part through a joint le­gal en­tity in­volv­ing the state-run Albanian Investment Corporation. The terms in­clude no tax dur­ing the con­struc­tion phase while the Albanian state un­der­writes the wa­ter, elec­tric­ity and sewage in­fra­struc­ture.

The sec­ond and larger ven­ture sits on the main­land, on the Vjosa-Narta coast near Zvernec, where Albania Land Development as­sem­bled the beach­front plots now un­der in­ves­ti­ga­tion. Conservationists de­scribe the wider zone, the Pishe Poro-Narta pro­tected land­scape, as one of the Mediterranean’s last largely in­tact coastal wet­lands, home to flamin­gos, more than 200 mi­gra­tory bird species, Mediterranean monk seals and nest­ing log­ger­head sea tur­tles.

The es­ti­mate for the pro­ject shifts de­pend­ing on who is speak­ing. The Sazan com­po­nent is con­sis­tently put at about 1.4 bil­lion eu­ros. Rama has re­ferred to a four-bil­lion-euro pro­ject once the Vlora main­land is in­cluded, and has said the two to­gether could be worth up to five bil­lion eu­ros. Most cov­er­age ren­ders the ag­gre­gate as roughly $4 bil­lion.

Land de­fend­ers and the ecol­o­gist Joni Vorpsi of PPNEA-BirdLife Albania de­scribe a pro­ject con­sist­ing of around 10,000 ho­tel rooms and vil­las spread across the is­land and the coast, a scale Vorpsi said would “completely de­stroy that wild re­gion.”

The money be­hind Affinity Partners

Affinity Partners is not US money in any or­di­nary sense. Kushner set up the firm in 2021, days af­ter leav­ing the White House, with no prior pri­vate eq­uity ex­pe­ri­ence, and it is funded largely by Gulf sov­er­eign wealth. The largest sin­gle backer is Saudi Arabia’s Public Investment Fund, which com­mit­ted $2 bil­lion in 2021 over the writ­ten ob­jec­tions of its own screen­ing panel. That panel flagged the fir­m’s in­ex­pe­ri­ence, an as­set man­age­ment fee it judged ex­ces­sive, the king­dom bear­ing most of the risk, and “public re­la­tions risks” tied to Kushner’s role as a se­nior ad­viser to Trump, and called the fir­m’s op­er­a­tions un­sat­is­fac­tory; the fund’s board, chaired by Crown Prince Mohammed bin Salman, over­ruled the panel and ap­proved the deal.

Qatari and Emirati money sits along­side the Saudi stake, and re­port­ing has put the fir­m’s to­tal for­eign-gov­ern­ment back­ing at around $4.6 bil­lion. That fund­ing base is why op­po­nents read the Albania deal as more than tourism. Kushner has served as an in­for­mal ad­viser to Trump dur­ing the sec­ond term, with a cen­tral part in ne­go­ti­a­tions on both the Russia-Ukraine and Iran wars, and crit­ics ac­cuse Albania of grant­ing him favourable terms to court the White House, a charge Rama de­nies. The pro­jec­t’s de­vel­op­ers say it will cre­ate jobs, at­tract in­vest­ment and raise Albania’s pro­file as a des­ti­na­tion, and that the mas­ter­plan is be­ing re­designed to pro­tect the en­vi­ron­ment.

Ivanka Trump’s is­land

Kushner an­nounced his Balkans plans in 2024. He and Ivanka Trump vis­ited the Vlora re­gion in early 2026, ac­com­pa­nied by ar­chi­tects and in­vestors, and Ivanka met with Rama. What pushed the pro­ject into Albanian head­lines was an in­ter­view Ivanka gave to the US pod­caster David Senra, pub­lished in late May.

0:00

/2:07

Youtube | video credit: @DavidSenra

She called it “an in­cred­i­ble pro­ject with my hus­band in the Mediterranean” and de­scribed Sazan as an “unbelievable, beau­ti­ful 1,400-hectare pri­vate is­land.”

Ivanka re­counted find­ing it by chance from a friend’s boat “We were on a friend’s boat, and we stopped for a swim,” af­ter which the cou­ple swam ashore and hiked bare­foot to the top.

She cast the build as care­ful stew­ard­ship, say­ing they had “developed the op­por­tu­nity to help re­al­ize its po­ten­tial and trans­form it.”

To Albanians, hear­ing a for­mer mil­i­tary zone the state had held for decades de­scribed as a pri­vate is­land the cou­ple had dis­cov­ered landed as an era­sure of their own coast, and lo­cals be­gan call­ing the place Ishulli i Trumpeve, Trump Island.

Clearing be­fore the per­mits

The clear­ing be­gan be­fore any of that was set­tled. Excavators and dump trucks moved onto the main­land site at Zvernec in late April, cut­ting ac­cess roads, lay­ing gravel over beaches and dunes, felling pine and clear­ing coastal for­est, with no com­pleted en­vi­ron­men­tal im­pact as­sess­ment and no pub­lic con­sul­ta­tion. BirdLife International, which doc­u­mented the work, re­ported that con­struc­tion had sealed one of the two chan­nels link­ing the Narta Lagoon to the sea, cut­ting the tidal ex­change that the la­goon’s fish and birds de­pend on, and ac­cused the gov­ern­ment of mis­lead­ing par­lia­ment about what was un­der­way.

PPNEA says some of the dam­age to the dunes can no longer be un­done, and a lo­cal of­fi­cer for the group mapped the de­struc­tion of at least one sea tur­tle nest be­neath the bull­doz­ers. The group’s ex­ec­u­tive di­rec­tor, Aleksandr Trajce, said the pub­lic had no warn­ing and watched the ma­chin­ery ar­rive with no no­tice; the gov­ern­ment later as­serted that a de­vel­op­ment per­mit ex­isted but has not pro­duced it, and Trajce de­scribed the process as show­ing “a to­tal lack of trans­parency.” Rama has since told par­lia­ment that the fi­nal pro­posal has not even been sub­mit­ted and the en­vi­ron­men­tal study is not fin­ished, which places the clear­ing ahead of the process meant to ap­prove or refuse it.

How the protests grew

Kushner an­nounced his Balkans plans in 2024, when he and Ivanka Trump vis­ited the Vlora re­gion in early 2026, ac­com­pa­nied by ar­chi­tects and in­vestors, and Ivanka met Rama. On the David Senra pod­cast last month, Ivanka de­scribed Sazan as a pri­vate is­land they had dis­cov­ered while swim­ming from a friend’s boat, a fram­ing of long-held pub­lic land that drew par­tic­u­lar anger once it reached Albanian au­di­ences.

Excavators and other heavy ma­chin­ery be­gan clear­ing the main­land site in late April, open­ing ac­cess roads, dig­ging into sand dunes and felling pine, with­out per­mits and with no en­vi­ron­men­tal im­pact as­sess­ment. Protests gath­ered at the end of May af­ter de­vel­op­ers ringed the site with barbed-wire fenc­ing and blocked pub­lic ac­cess to the beach. On 30 May, footage cir­cu­lated of pri­vate se­cu­rity guards punch­ing and drag­ging a pro­tester along the ground at the fenced-off site while oth­ers were threat­ened for try­ing to pull down the fences.

0:00

/0:42

Protestor video | X

Authorities re­voked the li­cences of two pri­vate se­cu­rity firms, ar­rested one guard, Gerald Biba, a 32-year-old em­ployee of the firm Major Security, charged with un­law­ful de­pri­va­tion of lib­erty and in­ten­tional mi­nor in­jury, sus­pended sev­eral po­lice of­fi­cers, and re­moved the lo­cal po­lice chief. About 15 pro­test­ers were also charged, and the State Police opened an in­ter­nal in­ves­ti­ga­tion into the com­mand struc­ture of the Vlora Regional Police Directorate. The fence has since been taken down.

Anger then spread to Tirana, where thou­sands ral­lied out­side Rama’s of­fice for con­sec­u­tive evenings un­der the ban­ner “Albania is not for sale,” chant­ing “cancel the pro­ject” and hold­ing signs read­ing “Ivanka, go home” and de­mand­ing the prime min­is­ter’s res­ig­na­tion. Albanian di­as­pora com­mu­ni­ties in New York, Athens, Milan and Brussels held their own demon­stra­tions, some car­ry­ing card­board flamin­gos.

Rama in­vited the pro­test­ers to send a del­e­ga­tion of about 20 peo­ple to dis­cuss so­lu­tions; they re­fused. The un­rest also opened a rift with Greece. After a Greek cit­i­zen was in­jured in the clashes, the Greek Foreign Ministry raised the treat­ment of pro­test­ers and the prop­erty rights of Albania’s eth­nic Greek mi­nor­ity with Tirana, and tied those con­cerns to Albania’s oblig­a­tions as an EU can­di­date.

Brussels and the ac­ces­sion ques­tion

The European Commission has put the pro­ject at the cen­tre of Albania’s mem­ber­ship prospects. A Commission spokesper­son told Politico that Albania should re­frain from ac­tions that could un­der­mine the clos­ing bench­marks for Chapter 27, the en­vi­ron­ment and cli­mate chap­ter of the ac­ces­sion talks, and that it ex­pected the au­thor­i­ties to act with­out de­lay. To close that chap­ter, Albania is ex­pected to align fully with EU law, in­clud­ing the Birds and Habitats Directives, re­peal the 2024 amend­ments to its Protected Areas law, and ter­mi­nate the 2015 Strategic Investments law that gives favoured pro­jects their fast track. Albania, a can­di­date since 2014 and in for­mal ne­go­ti­a­tions since 2022, is tar­get­ing mem­ber­ship by 2030 with tech­ni­cal ne­go­ti­a­tions to close by late 2027, a timetable Rama cam­paigned on and won a fourth term promis­ing. European Council President Antonio Costa, on a visit to Tirana, stated that ac­ces­sion re­quires Albania to fully im­ple­ment en­vi­ron­men­tal and rule-of-law stan­dards, be­yond merely adopt­ing European leg­is­la­tion on pa­per.

Albanian courts are still con­sol­i­dat­ing the in­de­pen­dence won in the 2016 jus­tice re­forms, and SPAK is the in­sti­tu­tion that re­form was meant to build. Whether the freeze holds or qui­etly lapses, whether the 2024 re­clas­si­fi­ca­tion is un­wound or left to stand, and whether the en­vi­ron­men­tal study that has not yet been writ­ten ever says no to a pro­ject al­ready un­der con­struc­tion, will mea­sure whether ac­count­abil­ity in Albania is struc­tural or ar­rives only when a Trump name is at­tached.

Photo by Martijn Baudoin on Unsplash

We’ve all worked with a rock­star de­vel­oper. They joined the team years ago, full of en­ergy. They had great ideas about new tech, new par­a­digms, new ar­chi­tec­tures. Their cut­ting-edge ideas left every­one else feel­ing a bit be­hind and out­dated.

They rewrote most of the com­pa­ny’s core ar­chi­tec­ture. They in­tro­duced new build processes, new tools, new lan­guages. They re­jected most pull re­quests, rais­ing the bar on what was ex­pected of every­one else. Nobody un­der­stood the code they wrote but no­body would ad­mit it.

All the hard­est tasks were as­signed to the rock­star. They’d have it done faster than any­one else. The en­gi­neer­ing al­ways sounded very im­pres­sive, even if the rock­star was the only one who knew how it fit to­gether.

Everyone else was mov­ing a lot slower in com­par­i­son. Everyone was strug­gling to keep up, to learn the new li­braries, and to do things the rock­star way.

A few years af­ter they joined the team, sud­denly they were gone. They had got­ten bored, and wanted a bet­ter job work­ing on a more chal­leng­ing pro­ject at a big­ger com­pany.

Dealing with the af­ter­math

Suddenly, you were asked to take over the rock­star’s pro­jects. You dug into the code, and you found your­self buried alive. The flow of data was so hard to fol­low, it seemed like some­one was try­ing to cover up a mur­der.

You started with try­ing to fix a sim­ple bug. Just get­ting the code to run on your lap­top took a week.

Half the code was writ­ten in a lan­guage you did­n’t un­der­stand. The other half was writ­ten us­ing li­braries you never heard of.

You tried to tell your boss that you think the code needs a rewrite. They did­n’t be­lieve you, be­cause it was writ­ten by the rock­star him­self. As you waded through the slop, you browsed job post­ings and fan­ta­sized about leav­ing.

Cleaning up af­ter a rock­star

I’ve worked with many teams and agen­cies who needed me to clean up af­ter these rock­stars. I ac­tu­ally love the chal­lenge of try­ing to un­der­stand and res­cue a messy code­base. It’s like sit­ting down with a box of tan­gled string lights, and pulling it apart un­til they’re us­able again.

As I’ve gone through the process, I’ve seen some pat­terns. These rock­stars ab­solutely love cod­ing, learn­ing, and us­ing new par­a­digms, and it shows. They’re al­ways push­ing them­selves to the edge of their abil­i­ties, writ­ing the most clever code they can. They are fo­cused on mov­ing as fast as they can.

Unfortunately, the last thing these rock­stars care about is writ­ing code that oth­ers can work with.

Along comes ar­ti­fi­cial in­tel­li­gence

In the past years, most teams have been over­whelmed by an army of rock­stars. Every time some­one starts a new chat, there’s the risk of adding a rock­star to the team.

The agent does­n’t re­mem­ber any­thing it did yes­ter­day. It hap­pily gen­er­ates tens of thou­sands of lines of code in min­utes. It works to com­plete tasks as fast as un­hu­manly pos­si­ble. It does­n’t care whether this code will fit with all the other code in the sys­tem. It also does­n’t care whether the sys­tem is be­com­ing more un­der­stand­able, or worse.

The AI has a tool­box of best prac­tices that prob­a­bly don’t ap­ply here. It in­sists on the “belt and sus­penders” way of do­ing things, even when the com­plex­ity out­weighs the ben­e­fit. When asked to re­view your code, it comes up with a long list of im­prove­ments, many of which you dis­agree with. The bar has been raised for every­one, and many feel they need to use LLMs or else they’ll fall be­hind for­ever. (Though I be­lieve it’ll be those who let LLMs write all their code who will ul­ti­mately be left be­hind.)

With so much gen­er­ated code, the com­plex­ity of a sys­tem can grow ex­po­nen­tially. It can be so com­plex that the only way to make sense of it is to use an LLM. Developers, teams, whole com­pa­nies can be­come ad­dicted and de­pen­dent on gen­er­a­tive AI.

Cleaning up af­ter hun­dreds of AI rock­stars

Sitting down with a pile of slop is­n’t as fun as clean­ing up af­ter a rock­star. At least the rock­star had some kind of de­sign in mind, and was try­ing to do their best.

A vibe coded pile of slop was­n’t writ­ten by a sin­gle ar­ti­fi­cial de­vel­oper. It was gen­er­ated across many dif­fer­ent chats, and many dif­fer­ent con­texts. It’s like a code­base writ­ten by hun­dreds of dif­fer­ent rock­stars, one fea­ture or bug­fix at a time.

Sometimes there’s so much tech­ni­cal debt that it can never be paid off.

Building soft­ware that lasts

There are many ways to use an LLM that don’t al­low it to act like a rock­star. You can lead the en­gi­neer­ing, and guide the LLM to gen­er­ate small snip­pets at a time. You can en­sure that the soft­ware is writ­ten in a way that every­one on your team will be able to un­der­stand and work with it eas­ily.

If you find your­self lost, un­able to un­der­stand what the LLM is do­ing or why, tap the brakes. It’s okay to move slower, to en­sure the soft­ware you’re gen­er­at­ing is high qual­ity. It’s also okay to pre­vent over-en­gi­neer­ing, to sim­plify and sim­plify un­til the ar­chi­tec­ture matches the com­plex­ity of the prob­lem.

It’s also okay to leave your LLM in the tool­box some­times, and to write code your­self. Craftsmanship will al­ways be in our hands, it’s one thing we can never out­source to a ma­chine.

Published on June 8th, 2026. © Jesse Skinner

Please turn on JavaScript in your browser and re­fresh the page to view its con­tent.

GentleOS/32

A hobby op­er­at­ing sys­tem for vin­tage 32-bit PCs.

Its goal is to pro­vide a sim­ple plat­form for tin­ker­ing with retro hard­ware and run­ning graph­i­cal in­ter­ac­tive apps on bare metal.

At min­i­mum, it only re­quires an i386 CPU, 4MB of RAM, and a VGA dis­play ca­pa­ble of 640x480x16 mode.

By de­sign it’s en­tirely mono­lithic, mostly con­fig­ured at com­pile time, and only sup­ports stan­dard PC de­vices: VGA/SVGA, key­board, PS/2 mouse, se­r­ial mouse, PC speaker. The only fu­ture plans are bug­fixes, op­ti­miza­tions, and adding more apps.

GentleOS/32 has a pure 16-bit spin-off called GentleOS/16, which tar­gets de­vices as old as 80186.

For de­tails on build­ing and run­ning, see USAGE.md.

Gallery

Attributions

Assets in ven­dor/​icons8 have been sourced from Icons8 us­ing the free li­cense and mod­i­fied

Assets in ven­dor/​icons8 have been sourced from Icons8 us­ing the free li­cense and mod­i­fied

Assets in ven­dor/​mona have been ex­tracted from the Mona Font and mod­i­fied (LICENSE)

Assets in ven­dor/​mona have been ex­tracted from the Mona Font and mod­i­fied (LICENSE)

Assets in ven­dor/​in­t10h have been ex­tracted from the The Ultimate Oldschool PC Font Pack and mod­i­fied (LICENSE)

Assets in ven­dor/​in­t10h have been ex­tracted from the The Ultimate Oldschool PC Font Pack and mod­i­fied (LICENSE)

License

Except where oth­er­wise noted, GentleOS/32 is li­censed un­der GPLv2.