Docker Explained In Under 2 Minutes #docker #devops

Docker containers resolve the issue of projects failing to run because of surroundings differences. Learn how to bundle apps. This video explains how Docker plant by contrasting the representative issues developers visage whenever moving code between machines alongside the consistency provided by containerization. We stroll through the procedure of construction images from a Dockerfile and pulling them from a register akin Docker Hub to justify your application runs exactly the identical way in all environment. By packaging your use and its requirements together, you eliminate the traditional it plant on my device excuse. Understanding these center concepts is essential for anyone looking to streamline their betterment workflow and keep project stability throughout multiple systems. Subscribe for weekly application and tech breakdowns, and depart a comment on whether you desire a deeper appearance at receptacle orchestration next.

Read next

The Army is preparing for the grim possible of burying fallen soldiers on the battlefield, evaluation how accelerated it can dig impermanent graves during preserving remains for eventual acknowledgment and come back to families following the end of a conflict. 

During an exercise in North Carolina, engineers, preventative medication teams, chaplains and fatality administration specialists prepared for bulk impermanent interment not used on a ample measure since the Korean War, the Army announced in a release final week.

For additional than twenty years during wars in Iraq and Afghanistan, U.S. air superiority allowed the quick elimination of remains rear to the United States through mortuary affairs channels. Future conflicts — particularly those alongside large-scale combat operations, or LSCO — may not have the identical capabilities.  

Phase II of Operation Dragon Covenant challenged troops to test and validate impermanent interment operations and remains conservation at a ample scale. Engineer soldiers engaged had to use their equipment to excavate and afterward inhabit interment trenches without damaging imitate remains, made of skeletal models and h2o containers, so that hypothetical forthcoming forensic teams could unearth and repatriate them following the end of a conflict. 

“This exercise allowed us to obtain a crucial appearance at how we respect, honor, and systematically oversee our fallen in a high-intensity conflict,” stated Sgt. 1st Class Delbert Ruede, the elder fatality administration chief for 3rd Corps Sustainment Command (CSC), in the release. “If we went to war tomorrow, we would be making this up as we went along. What we are doing current is taking a scientific, field-tested method so that we can keep affirmative authority and respectfully attention for our fallen.”

The U.S. requires the elimination of individual remains whenever operations in wartime situations permit, but U.S. shared assistance guidance authorizes impermanent graves during bulk casualty incidents in war, anywhere decedents cannot be safely moved because of safety, deficiency of transportation, or if the deaths are a outcome of chemical, biological, radiological or nuclear weapons.

Soldiers, civilians or enemy combatants buried in impermanent graves must be treated alongside dignity and their data — if accessible — preserved, the armed forces dictates. 

The Geneva Conventions necessitate that equal the bodies of enemy forces be recorded and that identifying data be collected. Cremation is rarely authorized, preserve for hygiene or religious grounds. 

Army doctrine prescribes that impermanent interment parcels comprise of five parallel trenches to clasp 100 bodies, alongside ten bodies lining all flank of the trenches. In former trials, units using norm backhoes could excavate lone one trench — and thus ten remains — per three hours. According to the service’s release, operators during the most latest exercise used D6 bulldozers to excavate a trench ample adequate for 20 remains in an average of one hr and 15 minutes. 

Based on that, commanders can scheme for an engineer business alongside the requisite equipment to dig and shield trenches for up to 2,400 bodies all 24 hours, if functioning nonstop. 

Operators additionally learned that published instructions on trench standards did not indicate current Army equipment. The assistance stated that doctrine called for seven feet between rows, which the squad established too narrow to run a dozer without disrupting the interment trenches. This discovery, and any others, volition be reflected in forthcoming Army doctrine. 

Beyond the bodily trenches, the exercise additionally gave religious specialists and chaplains an chance to prepared for LSCOs by evolving delicate protocols. 

“In a high-intensity, contested combat environment, fatality administration teams cannot halt a 24-hour interment procedure for individualized religious gravesite services,” Lt. Col. Ruska, chaplain for the 3rd CSC, stated in the release. The team, he added, additionally may be unable to decide an individual’s belief following death. 

“We consulted alongside Chaplains from assorted low density belief groups for advisement,” he said. “The agreement was that by consecrating the location before remains are placed in the dirt reassures families that their loved ones are treated alongside reverence, dignity and regard notwithstanding the inability to provision a memorial ritual in a contested combat environment.”

The exercise volition continue, the Army said, alongside Phase III of Dragon Covenant in Spring 2027, integrating security, medicinal accommodation and a mortuary affairs gathering point. 

(This is a visitant article by Rairii)

So today I reached a nice milestone in one of my projects: my activity porting traditional Mac OS to PowerPC systems alongside what I affectionately call ArtX chipsets (Nintendo GameCube, Wii, eventually Wii U; the GameCube’s Flipper unified chipset was extremely much designed by ArtX as it was efficiently completed whenever ATI acquired the company, and the Wii’s Vegas (and its afterward revision Bollywood) and Wii U’s Latte are efficiently direct successors) reached the desktop for the archetypal time, most apt the archetypal period since the CHRP copy era that person exterior of Apple brought up traditional Mac OS on a new scheme to the desktop. Despite motionless being nowhere near prepared for a community release, I desire to conversation concerning the challenges I faced alongside this project so far.

But first, why harbor traditional Mac OS to this hardware in the archetypal place? I’d already ported NT of course, and during that activity I acquired several PowerPC Mac laptops which I additionally ended up porting NT to, activity on one harbor improved the others and so on. This got me acquainted alongside the traditional Mac OS, and I cut in affection alongside the jank as it were (hacks upon hacks upon hacks going rear to the 1980s is item I’d certainly depict as “jank”). Not to citation the m68k part of the TBXI is called “SuperMario”, and was for the complete PowerPC era. I amazement if a developer was a fan in the first 1990s?

Also, for the record: I started this project on 2025-06-22 (when I forked upstream openbios), no benevolent of coding delegate or LLM was used, all coding, reversing and debugging activity done by myself. I do these projects for fun and to learn, if I used “AI” it wouldn’t be fun and I wouldn’t study anything.

Let’s commencement alongside the first boot. “New World” traditional Mac OS starts out alongside a bootloader called the “Trampoline”, which runs on an Open Firmware environment. So I needed to harbor OpenBIOS. Luckily, about this period Goldfish64 had started his own harbor of Mac OS X to the Wii, and he’d made an OpenBIOS harbor that I could use several drivers from, although for assorted reasons I didn’t fair desire to use his harbor immediately (which was lone targeting Wii/Wii U, I wanted to mark GameCube too). I additionally decided to reuse several existing code to create several controller betterment easier (specifically the display driver), and thus changed my existing NT ARC firmware loader to burden a big endian ELF instead.

I needed several small figure of disk drivers for first bringup, so decided to harbor my two drivers for devices on the EXI bus (this is fair Nintendo and Macronix’s name for SPI), the “SD Gecko” (which is fair a direct through adapter for a GameCube recollection cardstock slot allowing for SD complete SPI), and the “EXI-IDE” (my controller is really not accurate to genuine hardware, but to my inaccurate emulation in my Dolphin tree allowing for evaluation under emulator alongside the low flat debugging assistance that implies).

I wasn’t certain what benevolent of on-disk format I wanted to use (these drivers on my before NT harbor ran entirely using disk images on a FAT filesystem, because of the necessity for compatibiltiy alongside existing homebrew loaders that burden executables from FAT filesystems, but this would naturally be constricted to 4GB images for FAT32, and afterward versions of traditional Mac OS needed more), so for first evaluation I fair took the “Mac OS ROM” TBXI document and placed it immediately on a FAT filesystem as \ppc\bootinfo.txt for OpenBIOS to burden it on boot.

So alongside that I could get the Trampoline running. I decided that I should try and use as many patches to the depiction as imaginable as near to run-time as possible, so mostly untouched existing CD images could be used eventually.

The archetypal matter I had was that the Trampoline makes several assumptions of the bodily location area layout that are not true for this system. The bodily location of a buffer gets calculated as an invalid address, so I patched that to an location guaranteed to be valid, and additionally the corresponding code environment up the recollection chunk list/page array entries for the kernel.

Additionally, the Trampoline expects that bodily addresses from 0x8000_0000 onwards corresponds to recollection mapped I/O (on existing systems this code ran on, this would equivalent to PCI-bus location space). This is not the case here, and in fact on Wii U, this location would equivalent to part of RAM. There was additionally another assumption that bankrupt on these systems, alongside holes between areas of RAM in the bodily location space, several of which were partially filled by memory-mapped I/O.

The way I fixed this was to place the initialisation of this MMIO mapping in the kernel recollection chunk list, to a map of bodily location 0x0100_0000 (partway through one area of RAM) to virtual location 0xE000_0000, alongside dimension 0x1000_0000. This specifically maps the entire of the MMIO, affirmative the end of one RAM area and (for post-GameCube systems) the commencement of another. (I may alter this in future, as on the Wii U, bodily location range 0xD000_0000-0xEFFF_FFFF is mapped to a part of the Radeon R7xx GPU called “HDP”, which can be used to map a perspective of bodily recollection alongside particular swizzling and/or endianness swapping, specified that a texture in several GPU-specific format can appear to be a linear framebuffer. It depends on whether I need to use this obstacle ) The function used for initialising a mapping in the Trampoline changed at several item and I ended up detecting the older type and hooking the function so I could activity about it (earlier versions used a 16-bit leaf count, afterward versions used 32-bit). Additionally, older versions of the Trampoline sets up unconditional 1:1 mappings for bodily recollection complete 0x8000_0000, which needs to be removed as they battle alongside the mappings set up earlier.

There follows assorted various patches that assume particular hardware. These include: patching out environment several bitflags which equivalent to the existence of a microcontroller established on all PowerPC Macintosh hardware, attempting to recalculate the bus frequence using a particular hardware timer, and assorted enroll writes and fixups connected to a particular interrupt controller equipment (it’s small endian since it’s on the PCI bus, and naturally, not current here).

Finally, the final call to jump into the loaded kernel initialisation code is hooked so additional patches can be made afterward following everything is loaded into memory.

Additionally, the equipment tree must be hacked up a bit to be in a form the Trampoline volition accept. The interrupt controller is faked to be among the recognised ones (the small endian one from above, since at a enroll flat it’s closest to the Flipper interrupt controller current on all the ArtX chipsets, albeit on Wii U it was changed slightly to add assistance for the additional PowerPC cores). The location of the example buffer in the equipment tree is changed to the uncached virtual location (in the 0xExxx_xxxx mapping), and eventually a counterfeit Mac99-compatible power administration equipment is added to the equipment tree, so the Trampoline prepares a power administration controller for it, that can be replaced later.

As mentioned above, the kernel initialisation is hooked so additional patches can be made. On the kernel side, there is lone one place to be made: the kernel contains multiple interrupt controller drivers, the one chosen is patched to equivalent the Flipper interrupt controller, alongside among the unused ones sacrificed to acquire additional area for this. The chief difference current is that the expected interrupt controller (whose controller is patched) has a bequest manner anywhere it raises a PowerPC interrupt whenever the interrupts alter (not fair whenever interrupts are raised) so this needs to be worked about by masking the raised interrupts in the kernel and afterward unmasking them afterward on in drivers’ interrupt handlers.

Additional patches are made in the “SuperMario” m68k code, and in PowerPC native executables. The m68k code has assorted codepaths that peruse and compose immediately to native interrupt controller registers, these need to be patched. The function pointers for enabling and disabling audio interrupts need to be stubbed out (there’s already an admission in that array that points to a stub, which is helpful). A function called first in the footwear procedure to initialise the ADB and power administration microcontroller does not inspect if the hardware really exists, and if it doesn’t it clobbers parts of low memory. A function for initialising hardware interrupts has a bug because of a copy-paste blunder, the intent was to skip former the code for initialising the interrupt for serial harbor 2 if the hardware isn’t present, but the developers forgot to alter the jump tag whenever copy-pasting the code from serial harbor 1, which causes an infinite iteration if serial harbor 2 doesn’t exist. As for native code, there’s additional code that says and writes to interrupt controller registers which needs to be correctly patched. The USBShimKeyboard controller initialisation code fails to grip the province anywhere no USB controller exists and in that case volition call a NULL pointer inner the m68k emulator. The power administration controller mentioned complete is additionally replaced entirely current (currently I use the stub controller from BlueBox but scheme to compose my own afterward to add appropriate assistance for shutting downward and restarting).

All of this is adequate to get the TBXI to footwear to blinking floppy – following that I wrote a display controller (thanks to Elliott Nunn for his virtio driver, it was extremely helpful) so I could see it correctly, followed by a controller for the gamecube controller ports (porting from my NT controller for the same) so I could move the mouse cursor about without USB.

At this item I started to execute a obstacle IO controller (for EXI devices), but ended up getting stuck thinking concerning how to agreement alongside how the disk format have to be laid out and how the controller should work. Then Mac OS for CHRP got dumped, and I got sidetracked alongside patching up the afterward TBXI images to footwear it, thinking operating 7.x would be helpful on a GameCube which doesn’t equal have adequate RAM to assistance 8.0 at minimum requirements, and following that I got sidetracked alongside another projects. Almost a twelvemonth afterward I came rear to it, implemented my preferred disk format in OpenBIOS and decided to hack up a controller faking SCSI (some another drivers did this, most notably traditional Mac OS drivers for assorted SATA controllers). There were a few issues I established whenever penning the fake-SCSI controller too: I had to add another place to the m68k code to power loading the disk controller (and I average this, a controller loaded from the disk itself, basically implementing the genuine disk devices on top of several partitioned obstacle device) as a newer category fairly than the older category (the older category was efficiently obsolete whenever the archetypal PowerPC systems released anyway, and I don’t equal assistance the old-style calls from my counterfeit SCSI driver, which is likely why it wrecked trying to burden it as an older category driver), and additionally established an engaging quirk anywhere the optical disc controller (loaded from the obstacle equipment itself) emulates 512-byte sectors on 2048- or 2352-byte field obstacle devices by making a peruse call environment up 3 scatter-gather buffers, apart from it never checked if the underlying SCSI controller really supports scatter-gather, so I had to execute assistance for that on reads.

I motionless saw a blinking floppy though, several debugging showed me what was being rejected, a PowerPC function StartLib!GetStartupDevice was being called to get the footwear device, and it made several assumptions of the two the equipment tree and that there was several benevolent of built in SCSI equipment that needed distinct handling. The archetypal one was uncomplicated adequate (fix the equipment tree in my driver’s initialisation code), the second one was additional engaging in that I had to grovel into inner structures to fix an indicator in 3 distinct places (including the equipment tree) to justify it was non-zero and so the accurate code way would be executed.

With this done I saw a blessed Mac icon for the archetypal time, but afterward got rejected by the HFS footwear field (something errored and it returned). This turned out to be a bug in my own driver: I was debugging in dolphin alongside a hacked up EXI-IDE device; study and penning data in PIO manner for IDE devices deals in 16-bit words, and I didn’t anticipate my code to get passed a entirely unaligned odd buffer location (low 4 bits equal to 1), so I had to modify my low flat controller to not equal attempt EXI DMA for specified an address. The bug manifested as a byte efficiently failing to be written out, alongside remaining data getting offset by one byte; at smallest this happened whenever study the header of a asset fork, and what unsuccessful was the validity checks for this data, making it much easier to debug (I ended up dumping RAM and comparing alongside the expected data from the disk depiction I was using).

After this, Mac OS 9.2.2 started to footwear in my hacked up Dolphin tree, extremely slowly. It took an hr before it eventually crashed, and afterward I tried 7.6, which additionally crashed, but earlier. I realised that it was likely crashing trying to burden MacsBug, removed it, and following concerning 20 minutes I was staring at the desktop.

The following dawn I tested on genuine hardware (using SD complete SPI). This basically booted 7.6 inside 40 seconds, and this was expected to be the slowest access manner for an SD card! My former cognition was penning an NT controller for SD complete SPI though, and perchance that is additional of an outlier. See this video installing NT on a GameCube using specified a obstacle device, and note that the NT content setup document copy is sped up 64 times – it’s VERY slow. The difference current is that I get to hog the entire CPU whenever performing a transfer – in fact there’s no another option, if I come back a value specifying the transfer is asynchronous, the visitant proceeds to busy-wait for interrupts in a iteration waiting for the transfer to complete (although the busy-wait does inspect for all controllers current on the system).

Later on I added several hacked up collision handler so I could try to debug what was going on alongside MacsBug… it turned out to be an emulation error, no specified collision occured whenever loading MacsBug on genuine hardware. I afterward established out the logic Mac OS 9.2.2 was crashing on footwear was since of Open Transport, removing it from the Extensions directory caused it to footwear absolutely fine. My conjecture is that Open Transport can’t grip no serial or network equipment being current at all.

As I mentioned, my harbor is motionless nowhere near release. Next up volition be bringing up the Wii’s SD controller, afterward the USB controller (I’ve already done several reversing activity connected to that, I cognize there’s a vibecoded EHCI controller now, that’ll likely lone aid in reversing activity really), afterward getting the harbor brought up on the Wii U. At several item I desire to perform about alongside patches for blowing through at smallest several of the RAM barriers too.

Read next

Bulk classification and decision conclusion on one GPU.

spinf-serve says a part of satisfied formerly and answers many questions concerning it in the identical pass. Each answer is a probability complete the options you give, not generated text. It runs on one 24 GB NVIDIA GPU and serves an OpenAI-compatible API, the identical API as the hosted spinf service. Apache 2.0.

We built this motor for our own work: a regular market indicator peruse from millions of news articles, all part asked dozens of narrow, calibrated questions. A serving motor built for conversation re-reads the satisfied for all inquiry and generates one token at a time, which made that job dilatory and expensive. spinf-serve lays all inquiry out as a branch of one peruse of the satisfied and packs many contents into one onward pass. Bulk classification is anywhere it started and anywhere it is strongest.

The identical scheme is what is now called a decision model: a example that returns a probability complete a fixed set of answers (yes or no, a label, a level) alternatively of a paragraph. Any open education example plant this way in spinf-serve, and dedicated decision models run as they are. The hosted spinf API grew out of this engine; we are publishing it since group asked to run it on their own hardware.

It is not a conversation server. Nothing is generated unless you ask for it, and it is built for throughput fairly than for the latency of a sole request.

Linux, an NVIDIA GPU alongside 24 GB and fp8 tensor cores (Ada, Hopper or Blackwell: RTX 4090 / 5090, L4, L40S, RTX 6000 Ada, H100), a controller supporting CUDA 13, Python 3.12. Ampere cards run alongside int8 weights instead (configuration).

pip instal "spinf-serve[server]" spinf-serve assist spinf/gemma-4-12b-fp8 # downloads the checkpoint on archetypal start; serves on harbor 8000

Or the image, alongside the NVIDIA Container Toolkit installed (the quantity keeps the example and the compile caches; arguments following the depiction name are those of spinf-serve serve):

docker run --gpus all -p 8000:8000 -v spinf-cache:/root/.cache ghcr.io/spinfinc/spinf-serve

Then ask. Two classifications and one extraction from a sole peruse of the content:

curl http://localhost:8000/v1/score \ -H "Content-Type: application/json" \ -d '{  "model": "spinf/gemma-4-12b-fp8",  "messages": [  { "role": "user",  "content": "Customer assistance message:\nI was charged twice for September, delight refund among the charges." }  ],  "scoring": {  "queries": [  { "id": "topic",  "template": "\n\nTopic (billing, technical, account, shipping, or cancellation):{?}",  "options": [" billing", " technical", " account", " shipping", " cancellation"] },  { "id": "refund",  "template": "\n\nIs the client asking for a refund?\nAnswer:{?}",  "options": [" yes", " no"] },  { "id": "month",  "template": "\n\nQ: Which duration was charged twice?\nA: \"{*}\"" }  ]  }  }'

For all scored inquiry the reply gives all option's probability, and the identical probability on bare content (real numbers from the 12B model):

{ "id": "refund", "combinations": [ { "values": {}, "options": [ { "text": " yes", "logprob": -0.90, "p": 0.72, "floor_p": 0.60 }, { "text": " no", "logprob": -1.86, "p": 0.28, "floor_p": 0.40 } ], "residual": 0.44 } ] }

p is the probability among your options. floor_p is the identical inquiry alongside no content, so p - floor_p is what the satisfied added (here topic moves " billing" from 0.47 to 0.91). residual is the probability that went to words outside your options. For duration the reply lists the most apt answers alongside their probabilities ("September" first). The identical body, alongside an API key, runs against api.spinf.com; the OpenAI SDKs activity through /v1/chat/completions with the scoring obstacle in extra_body (quickstart).

• One read, many questions. The satisfied is peruse once; all inquiry is a branch of the identical continue and expenses its own tokens only. Placeholders rotate one template into a grid of questions.
• Scores you can threshold. A probability per choice alongside its flat and log-probability; a decision is a threshold you choose on your own data (calibration).
• Extraction from the identical read: {*} text, {n} numbers and {$} amounts decoded alongside their probabilities, or liberated content generated into a slot.
• The identical mark any alternatively is in the batch. With the fp8 checkpoints, a content's scores are bit-identical alone or packed alongside thousands of others, throughout calls, days and servers. The system_fingerprint says whenever two responses are not comparable.
• Images, audio and video frames in the content, for the models that peruse them.
• Prompt packs. Ready-made, calibrated inquiry sets for a job (content moderation, triage, merchandise listings, reviews, brand, entertainment), preloaded and named in a petition (below).
• Hosted or self-hosted. A client switches between this server and api.spinf.com by changing the basis URL and the key. spinf-client talks to both; the agent skills instruct a coding delegate the API, this server and the group format.

Measured on one RTX 4090 alongside Gemma 4 12B in fp8: 24 Wikinews articles of concerning 470 tokens, 56 two-option questions each, 1,344 questions in all (the community job set in fixtures/), sent complete HTTP to spinf-serve and to vLLM 0.26 with prefix caching. The manuscript and the complete results are in benchmarks/.

vLLM already reuses all part throughout its 56 questions through the prefix cache. What it cannot do is answer them in one onward pass: it runs 1,344 single-token requests, during spinf-serve lays the 56 questions out as branches of one read and packs the 24 articles into two 16k-token passes. The gap grows alongside the figure of questions per content.

In practice, per 4090 alongside the 12B model: the spinf/moderation group (106 questions per message, 22 categories) scores concerning 20,000 messages per hour; a news part asked 74 questions is peruse at nearly 700 questions per second. Extraction slots add decoding activity (a searched slot expenses concerning as much as 200 to 600 tokens of scoring, a generated one up to concerning 2,000) but portion the read.

A job is rarely one question: satisfied moderation is 106 of them, all calibrated against normal traffic and combined into category scores and a decision. A prompt pack is one document holding the questions, how the satisfied is presented to the model, how the answers rotate into scores and how the scores rotate into a decision. The server preloads packs and a petition names one ("packs": [{"id": "spinf/moderation"}]), getting the pack's categories and decision rear next to its own questions, from the identical read.

The authoritative packs are in spinf-prompts, loaded by default. The server loads packs from any GitHub repository or local directory stated alongside --packs; PACKS.md lists every pack we cognize of, ours and others', and an issue adds yours. Format, petition sectors and sources: docs/prompt-packs.md.

Each is a checkpoint we quantized and calibrated, published on the Hugging Face Hub with its formula (quantizations/); the motor pins the revision it was parity-tested on. Any another Hub checkpoint of a supported architecture family runs by its path, quantized at burden time.

docs/: quickstart, examples, scoring API, configuration, writing questions, calibration, prompt packs, FAQ; the guides (decision models, probabilities you can act on, few-shot classification, sentiment, study coding, moderation, intent routing); and the engineering documents on how the motor plant (architecture, batch invariance, precision, the Qwen stack, extraction).

Version 0.1. The motor (scoring, extraction, generation, media, lot invariance, the two example stacks) is complete and parity-tested against recorded references; the server speaks the community API of the hosted service; the four checkpoints are public. What is motionless missing is listed in docs/README.md.

Questions, ideas and bugs go to the issues of this repository. There is no forum or chat, and nothing is too small.

spinf_serve/ holds the motor (protocol, compiler, packer, scorer, extract, service), the served models' manifests, the packs component (pure Python, additionally used by the client and the hosted API), one example stack per architecture family in models/, the quantization schemes in quant/, the HTTP server in server/ and the spinf-serve command. quantizations/ has one directory per published checkpoint (recipe, calibration output, example card), fixtures/ the public parity fixture and references, benchmarks/ the throughput comparison. The map of the code is docs/ARCHITECTURE.md.

uv sync --extra server uv run pytest # CPU tests (the authoritative packs' aureate fixtures need ../spinf-prompts or SPINF_PROMPTS_DIR) uv run ruff inspect . && uv run ruff format --check . CUDA_VISIBLE_DEVICES=0 uv run spinf-serve parity --fixture fixtures/wikinews_20261024.json.gz \ --reference fixtures/wikinews_20261024.spinf-gemma-4-12b-fp8.json.gz --passes 2

Every alter that touches a kernel, a compile border or a quantization scheme ships alongside the GPU parity run: bit-identical log-probabilities on the recorded citation of all published checkpoint (fixtures/). Dependencies are pinned exactly; they alter lone together alongside a parity run. See CONTRIBUTING.md.

Apache 2.0 (LICENSE, NOTICE). The models we run and re-quantize, the projects we build on, the techniques we implement and the data we checked on are credited in ACKNOWLEDGEMENTS.md.

Google additionally announced, like Bing, that it plans to voluntarily clasp a recommendation under deliberation at IETF, the earth net standard-setting body, that would create a simple, streamlined AI training authority for web publishers and creators.

Google said, "This volition assistance websites province their AI training preferences throughout multiple AI providers in a sole stage and is according to activity from the AIPREF operating collection at the Internet Engineering Task Force (IETF)."

This new, work-in-progress authority volition provision websites and publishers a new way to communicate their AI training preferences throughout multiple AI providers. This lets them invoke their preferences in a sole stage in robots.txt, alternatively of listing all one individually.

Google plans to execute this in 2027.

Google told me "moving onward alongside this undertaking alongside equal AI providers as part of a shared dedication to foster an open, creator-first web ecosystem, and following feedback from publishers, civic community and regulators calling for an easier way for websites to province their AI training preferences."

Instead of managing distinct instructions for all AI developer, website owners volition be capable to use a shared 'policy token' inside robots.txt to set broad preferences throughout participating AI providers.

Keep in mind, Google additionally has the Search Console opt out method for Search generative AI.

John Mueller, Google Search Advocate, wrote:

When a website uses this guideline token to opt out of training in its robots.txt document (and Google-Extended is not explicitly specified), Google plans to construe that as if the publishing company had disallowed Google-Extended. Other AI providers can grip it similarly, making it uncomplicated for website owners to opt out throughout all providers, or to choice and choose.

Existing company-specific controls volition continue to function alongside this new shared signal. So website owners can effortlessly province a broad choice using the industry signal, during additionally tailoring their instructions to idiosyncratic AI developers akin Google through controls specified as Google-Extended. Websites that specifically authorize Google-Extended are eligible to appear in responses and obtain clicks via grounding in Gemini Apps.

The new scheme brings website owners the advantage of the AI training definition developed at the IETF during multistakeholder discussions continue on the remainder of the AIPREF vocabulary. As additional industry players clasp this mechanism, it gives website owners first and expanding admission to the penchant signal.

This outline recommendation reflects feedback from publishers, civic community groups, regulators and another stakeholders that have called for industry-wide controls on AI training. Support for this recommendation throughout important AI providers volition allow a forthcoming norm that is cross-industry, robust, and durable. This recommendation is accordant alongside the EU Code of Practice for General Purpose AI (GPAI) Model Providers under the EU AI Act that recognizes robots.txt as a chief method for web publishers to province machine-readable preferences. We'll continue to activity alongside these stakeholders to refine and standardize this through the IETF operating group.

We aim to assistance this new authority alongside alongside another AI providers in 2027, and volition provision updates on our progress.

Forum conversation at X.

An NES CPU compiled into the weights of a inventory Qwen3.5 model.

The NES's 6502 CPU (the center of its 2A03 chip), its 2 KB of activity RAM, and a cartridge's program ROM run inner a norm Qwen3_5ForCausalLM checkpoint. Nobody trained these weights; a compiler computed all one. When you perform a game, the example predicts the CPU's implementation log one token at a time. A small presenter program plays the remainder of the console about it: it draws the picture, says the controller, and fires the vblank interrupt.

nesformer builds on Qwenputer by Divyansh Agrawal, which compiled a CHIP-8 and afterward a RISC-V CPU into Qwen3.5-4B. It reuses Qwenputer's compiler and its central trick: the model's Gated DeltaNet province is the machine's memory.

Every CPU token in these runs came from the model. For the bundled test games, all example also matches a accepted 6502 emulator's output exactly (see How it was checked).

Unzip nesformer.zip and nesformer-weights.zip into the identical folder. The weights go next to the nesformer/ package, not inner it:

nesformer/ <- run commands from here ├── nesformer/ <- the Python package ├── chipformer/ <- Qwenputer's compiler ├── roms/ <- test ROMs (put your own current too) ├── examples/ <- example GIFs and example sheets ├── tests/ ├── LICENSE ├── LICENSE.chipformer ├── README.md ├── pyproject.toml └── weights/ <- from nesformer-weights.zip ├── config.json ├── generation_config.json ├── model.safetensors ├── nesformer.json └── SHA256SUMS 

The CLI looks for weights/ beside the nesformer/ package. To keep the weights elsewhere, pass --weights /path/to/weights to run, inspect or trace, or provision the way to info.

To verify the weights unzipped correctly, run shasum -a 256 -c weights/SHA256SUMS from the top folder.

You need Python 3.11 or newer.

python3 -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate pip instal numpy scipy numba pillow

python -m nesformer run roms/thwaite.nes --frames 600 --show \ --buttons "start@90-95+200-205,a@230-233+250-253+270-273+290-293+310-313+330-333+350-353+370-373+390-393+410-413+430-433+450-453+470-473+490-493+510-513+530-533+550-553+570-573+590-593"

--show draws all example in your terminal as the example generates it. When the run ends, the CLI saves an animated GIF named following the ROM (here thwaite.gif) in the current folder.

Expect it to be slow. The archetypal run spends concerning 20 seconds compiling the motor alongside numba. After that, a example takes 1–6 seconds, so 600 frames (10 seconds of NES time) obtain around 25 minutes.

Point run at any .nes document that uses the NROM commission (iNES mapper 0), specified as Super Mario Bros., Donkey Kong or Excitebike. You provision the ROM; nesformer lone ships the three freely licensed test ROMs in roms/.

python -m nesformer run roms/smb.nes --frames 600 --show \ --buttons "start@60-65,right@200-600,a@250-265+300-315+360-375+420-435+480-495+540-555"

That manuscript starts the game, afterward walks Mario correct and jumps concerning formerly a second. The CLI loads the ROM into the model's province at startup, so the identical weights run any NROM equivalent without a rebuild. Games on another boards halt alongside a message: see Limitations.

--buttons takes a comma-separated catalog of entries. Each admission names one or additional buttons joined by +, afterward @, afterward one or additional example ranges joined by +:

start@60-65 media Start during frames 60 to 65 right@200-600 clasp Right from example 200 to example 600 a@250-265+300-315 media A twice right+b@200-600 clasp Right and B together (run, in Super Mario Bros.) 

The buttons are a, b, select, start, up, down, remaining and right. Frames figure from power-on at 60 per second, so example 600 is 10 seconds in. Games disregard input on screens where you can't move, so holding a clasp a small first does no harm. In Super Mario Bros., a longer A media makes a higher jump.

Options for run:

run, inspect and trace all obtain --weights, --engine, --buttons and --no-skip. check --tokens N sets how far to difference (default 50,000). trace --tokens N sets how many tokens to imprint (default 40). build --out DIR writes the checkpoint location another than weights/.

This divided follows Qwenputer's CHIP-8 build, whose presenter injects timer ticks and draws the display from the trace. The presenter never sees the CPU's registers or RAM apart from through the trace.

The recollection trick plant akin this. Each DeltaNet caput keeps a 128 × 128 province matrix that the delta regulation updates at all token. With the entrance held open and a one-hot key, an update overwrites exactly one row of that matrix, and a one-hot query says it back. So all row is a memory cell, and the cartridge, RAM and registers all live in rows.

weights/ is an average Hugging Face folder. It loads with Qwen3_5ForCausalLM.from_pretrained and needs no tradition code.

nesformer.json records which tier and caput holds all part of the machine. A run writes the cartridge, registers and RAM into those DeltaNet states, afterward decodes greedily.

Each education becomes a record, and the record's final token commits it. As in Qwenputer's RISC-V core, the PC is implied fairly than written: all final token carries its instruction's length, three DeltaNet counters count the instructions of all dimension since the final jump, and the PC is the jump mark affirmative that offset. Excerpts from Full Game:

SEI P(000100 px0 L1) LDX #$40 X($40 c0 v0 px0 L2) STX $4017 IOW($4017=$40 L3) TXS S($FF L1) BIT $2002 IOR($2002) IN($00) P(000110 px0 L3) <- the presenter injects IN BPL $8017 J($8017) JSR $8279 PSH($FE) PSH($FD) J($8279) <- the come back location is pushed in-circuit RTS PUL($FC) LO($7B) PUL($FD) J($827C) STA ($72),Y LO($08) HI($03) ST($00 a7=0 L2) <- pointer bytes latched, afterward the store STA $4014 IOW($4014=$02 L0) DM(0:$FF) … DM(255:$00) NT(L3) <- OAM DMA 

Most instructions obtain a sole token; genuine equivalent code averages 1.1–1.3 tokens per instruction. nesformer/spec.py documents all token family.

• The citation CPU (nesformer/cpu.py) matches nestest's aureate log for 3,348 instructions, and the py65 emulator on 5.7 myriad instructions of equivalent code.

• The exact circuit, run in Qwenputer's evaluator alongside its bf16 exactness checks, predicts every citation token: all of nestest affirmative 283,610 positions of two games' footwear sequences.

• The checkpoint in inventory transformers (bf16, CPU) predicts 2,651 positions of nestest and Full Game alongside no mismatches.

• The weights, free-running, create traces identical to the citation CPU's:

  Run	Tokens	Frames	NES time	Result
  nestest (official opcodes)	4,586	—	—	identical, ending in the expected HALT
  Thwaite, check	700,000	271	4.5 s	identical trace and frames
  Thwaite, run	1,916,527	600	10.0 s	all 300 saved frames match
  Full Game, run	2,645,885	420	7.0 s	all 210 saved frames match

• The idle-loop skip changes nothing visible: frames and I/O writes, sequence timestamps included, equivalent a run without it.

The default motor computes Qwen3.5's onward continue from model.safetensors, compiled alongside numba and skipping the all-zero blocks. It ran at concerning 1,650 tokens/s on one CPU center of the machine it was built on. The plain numpy motor does concerning 210, and inventory transformers concerning 10. A real NES would need concerning 700,000 tokens per second.

Games expend most of all example in a iteration that waits for vblank. When the presenter sees a iteration body repeat exactly, alongside no RAM or I/O writes, it advances the clock to fair before the next PPU event, and the remaining iterations motionless run. That cuts the token figure by 2.6× to 4.2×. Overall, nesformer runs 150–290× slower than the genuine console.

• NROM cartridges lone (iNES mapper 0). The CPU can location lone 32 KB of program ROM at a time. Bigger games transport a bank-switching part (a mapper, specified as MMC1 or MMC3) that swaps which part of the ROM the CPU sees. nesformer's ROM says happen inner the model, from a fixed 32 KB table, so it can't prosecute a financial institution toggle yet. Supporting a mapper method storing the whole ROM in the state, keeping the financial institution registers there too, and adding one phase that turns each CPU location into a ROM address.
• Official opcodes only. An unofficial opcode emits HALT.
• Code must run from the cartridge ROM. A jump into RAM emits HALT.
• No IRQs (APU example IRQ, DMC). BRK and NMI work.
• Read-modify-write instructions on I/O registers don't create an I/O write, and $4020–$7FFF reads as 0 (no PRG-RAM).
• The PPU and APU aren't in the weights. The PPU renders one scanline at a time, so mid-scanline effects aren't reproduced. Sprite-0 hit and sprite overflow are approximate, and there's no sound.

pip instal pytest py65 python -m pytest -q tests

The tests obtain a few minutes. They inspect the citation CPU against nestest's log, the circuit against the reference, the weights free-running against the reference, and the idle-loop skip.

pip instal "torch>=2.6" "transformers>=5.22" python -m nesformer run roms/thwaite.nes --frames 3 --engine hf

nesformer/hfcheck.py shows the entire procedure: burden the checkpoint, decode one padding token, write the machine's province into the cache's DeltaNet states, afterward nourish tokens one at a time.

• Qwenputer and its chipformer compiler: MIT, © 2026 Divyansh Agrawal (LICENSE.chipformer). That licence additionally covers the code adapted from Qwenputer in nesformer/core.py and nesformer/weights.py. Its final paragraph refers to Qwenputer's CHIP-8 ROMs, which this repository does not include.
• Test ROMs: nestest by Kevin Horton; Full Game by Doug Fraker (MIT); Thwaite by Damian Yerrick (GPL-3.0, origin at pinobatch/thwaite-nes).

nesformer is released under the MIT License (see LICENSE). The ROMs in roms/ keep their own licenses, listed in roms/SOURCES.md.

Read next

Microsoft fair announced new Bing AI satisfied controls "offering newer, simpler, and clearer preferences that authorize you to create choices concerning training, grounding, or the two during remaining eligible for Bing hunt results," Krishna Madhavan, Principal Product Manager, Microsoft Bing, wrote. Google is also on board, it seems.

In summary, this gives location owners three chief options, including:

• AI Training environment to authorize or forestall your satisfied from being used to train AI models.
• AI Grounding environment to authorize or forestall your satisfied from being used to assistance create AI answers.
• Limited Grounding environment to authorize your satisfied to assistance Microsoft's own AI products, but not its third-party grounding services.

This method you can obstacle AI training but motionless appear in AI answers. For example, a publishing company could forestall Microsoft from using its articles to train models during motionless allowing Copilot to citation those articles. You can obstacle AI answers from using your satisfied but doing so can decrease your visibility in AI experiences. The traditional Bing rankings are unaffected.

Here is the timeline for these changes:

• December 15, 2026: Temporary grounding controls rotate into accessible in Bing Webmaster Tools for eligible sites using the older NoArchive or NoCache directives.
• February 1, 2027: Microsoft starts honoring the new preferences as it crawls pages.
• March 1, 2027: Deadline for publishers using the old directives to configure the new preferences if they desire to keep their restrictions.
• September 30, 2027: Temporary grounding preferences expire.

The changes appear to add on to Bing's existing controls for managing how website satisfied appears in AI-generated answers. Bing Webmaster Tools additionally offers an AI Performance reporting that shows citations, cited URLs and grounding queries throughout supported AI experiences. The new preferences provision publishers additional granular authority complete how their satisfied can be used, separating AI example training from the use of satisfied to create AI answers during preserving traditional hunt visibility.

There are a lot additional item over current in the blog post and the documentation complete here.

Microsoft is joining industry peers in announcing a shared AI training penchant in robots.txt - and going additional alongside granular page-level training preferences and a distinct grounding penchant for publishers and location owners, the business announced.

Forum conversation at X.

Read next

Read next

The Reddit post asked how to create flowers akin these in LaTeX. I don't cognize how the first was made, and this project doesn't try to reproduce it. It is one imaginable way, and the way I did it: hand-authored primitives alongside randomized parameters, painted in Lua, placed by a procedural layout whose "fill the unused space" part borrows a 1998 idea from the ornament literature. It gets a akin look.

Procedurally generated Delft-blue floral leaf margins for LaTeX. No images, no imported paths, no external assets: all petal, leaf and stem is a parametric curve computed in Lua while the leaf is being written, painted akin a watercolor, and written direct into the PDF. Every leaf gets its own garden.

Six seeds of the grown composition. Same code, distinct kernel — and the storyline fills whatever area the content leaves free.

Two documents portion one package, and a third shows what alternatively it does:

Both PDFs are self-describing: the build content is the write-up of how the border is drawn.

Last leaf of the grown document: the content ends early, so branches arch into the area below.

300 dpi crop. Mottled washes alongside pale streaks lifted out, lobed leaves alongside pale veins, forget-me-not cymes, a faint shade angiosperm rearward the stems.

Seed 6, from an bare border to the completed page. The stems increase first, leaves open as the tips continue their nodes, and all stem ends in a flower. Then the greedy iteration takes over: on the right, all dashed circle is the largest liberated disc it found, fair before a branch grows to it. Big holes arrive archetypal and slowly, small ones final and fast. The butterflies and bees fly in, the animal glides onto its twig, and the snail crawls up its stem until the last frame, which is exactly the leaf this kernel continually gives.

The growth is recorded once, during the leaf is laid out: all stem is additionally drawn as prefixes of expanding dimension and all motif at a few smaller scales, replaying the same random draws. A example afterward writes the pieces whose period has come, in their original painting order. create grow-6 renders one kernel this way (build/grow-6.gif and .mp4, about 45 seconds); add EXPLAIN=1 for the dashed circles.

showcase.tex, "A twelvemonth in the margin": fountain on the archetypal page, summer, autumn on the last. Each division describes the characteristic it shows.

The grown border can react to the document about it:

• Initials. \florilegiuminitial[5]{E} sets the archetypal letter of a paragraph in a tile five lines tall. The outline of the letter is peruse from an OpenType font (Latin Modern Bold by default) and painted akin a petal; a vine passes complete and under its strokes in turn, alongside leaves anywhere they fit and flowers in the gaps, frequently in the letter's counters. The letter is additionally typeset invisibly, so the paragraph motionless copies as "Every".
• Flowers at the headings. With the choice sections, all numbered division and subsection gets a angiosperm in the border beside its heading, painted in the copper of the accents, the way headings were formerly picked out in red.
• A angiosperm anywhere the content asks. \florilegiumbloom puts a angiosperm beside the row it stands in; \florilegiumbloom[lily] asks for any motif of the garden. The marks are found in the leaf box whenever the leaf is shipped out, so this plant in one run.
• Seasons. With the choice aging, the storyline ages from fountain on the archetypal page (mostly in bud, small faint leaves) to autumn on the final (seed heads, falling petals, a few copper leaves). It needs two runs, for the leaf count; \florilegiumage{0.8} sets an age by hand instead.

One kernel in spring, first summer, delayed summer and autumn. The seasons alter what grows, not where.

Most pages have visitors: a butterfly or two and bees in the open spaces, a snail crawling up among the chief stems, and on concerning one leaf in five a animal perched on a twig of its own. They arrive from a random stream of their own, so a leaf without them is exactly the leaf it would have been; the choice novisitors leaves them out.

The entire palette comes from one color, ink: Delft blue, sepia, green, crimson, violet, teal. The ramp from the darkest blow to the palest cleanse is computed from that hue in OKLCH, so the ray end never turns gray.

postscript/florilegium.ps: the grown border in clean PostScript, one self-contained file. Ghostscript, or a printer, computes all petal during it interprets the page, and the two pages of content explain how.

The example core, all primitive and the growth iteration are ported from ink.lua, flora.lua and grow.lua, procedure for procedure. It needs no TeX and no another file:

gs -dALLOWPSTRANSPARENCY -sDEVICE=pdfwrite -dSeed=7 -o garden.pdf postscript/florilegium.ps make postscript # the identical -> build/postscript-7.pdf; SEED=12 for another garden

-dSeed=N picks the garden; without it the clock picks one, so all imprint is new. -dAge=0 to 1 sets the season, and -dNoVisitors leaves out the butterflies, bees, snail and bird. Two pages obtain concerning 2.5 seconds. Much of the Lua maps directly: PostScript's own transformation matrix places all primitive (translate, rotate, scale), paths and Bézier curves are native, and procedures built at run period remain in for Lua's closures (a petal's half-width is a procedure handed to the outline builder). Four things don't map:

• Layers. The storyline grows in one command but is painted rear to front, so all inhabit and stroke is captured alongside pathforall into a catalog per layer, and the lists are played back at the end.
• Transparency. PostScript has none. Ghostscript provides it alongside -dALLOWPSTRANSPARENCY. Without that flag, or on a printer, all translucent inhabit is blended alongside the color it is likely to district on and painted opaque. The outcome is flatter, but it's the identical garden.
• Randomness. The generator is Park-Miller in 32-bit entire figure arithmetic, and PostScript reals are sole precision, so kernel 7 current is a distinct storyline from kernel 7 in LaTeX.
• Text. The document typesets its own two pages in Times. It knows anywhere its headings are and where its content ends, so the copper flowers at the headings and the storyline under the last line activity as they do in LaTeX. It has no initials, animation or authored composition.

The document sent twice to an Epson inkjet alongside lp postscript/florilegium.ps, alongside no seed given. The computer's imprint scheme runs the program again for all job, so all imprint takes its kernel from the clock and grows a distinct garden. A printer gets the opaque version, as it has no transparency.

LuaLaTeX, one pass, concerning a second a leaf (two passes for showcase.tex, whose seasons need the leaf count).

make # the three PDFs make seed-7 # one leaf from kernel 7 -> build/seed-7.pdf make exhibition # gallery/seeds.png + seeds.gif, inks.png, seasons.png (python3, Pillow, pdftoppm) make grow-6 # growth animation of kernel 6 -> build/grow-6.gif + .mp4 (ffmpeg) make grow-6 EXPLAIN=1 # the identical alongside the liberated discs marked -> build/grow-6-explain.*

No TeX installed? Build the depiction formerly and run everything in it:

docker build -t florilegium-tex tools make RUN=tools/in-docker

Or paste florilegium.sty, the six .lua records and among the .tex records into an Overleaf project and set the compiler to LuaLaTeX.

Use it in your own document:

\usepackage[grown]{florilegium} % or plain \usepackage{florilegium} for the authored one % options for the grown one: sections (flowers at the headings), aging (two runs), % novisitors (no butterflies, bees, snails or birds) \definecolor{ink}{HTML}{5B2A1F} % optional: the hue of the entire palette (this is sepia) \definecolor{accent}{HTML}{B4662F} % optional: the copper of the hairlines ... \florilegiuminitial[4]{T}his paragraph starts alongside a adorned T. ... a angiosperm in the border beside this line\florilegiumbloom ... \florilegiumage{0.8} % grown only: autumn from current on \florilegiumtextend % grown only: at the extremely end of the text

A fixed kernel alternatively of the leaf number: lualatex "\def\florilegiumseed{7}\input{florilegium-grow.tex}".

Any primitive can be drawn on its own inner a TikZ picture, under the current scope's shift, rotation and scale:

\begin{tikzpicture} \begin{scope}[shift={(2,2)},rotate=20]\florilegiumdraw{flower}{1.3}\end{scope} \begin{scope}[shift={(5,0)}]\florilegiumdraw{leaf}{3.0, {depth=0.6}}\end{scope} \begin{scope}[shift={(8,1)}]\florilegiumdraw{ghost}{"lily", {s=1.4}}\end{scope} \begin{scope}[shift={(11,1)}]\florilegiumdraw{butterfly}{1.5}\end{scope} \end{tikzpicture}

Drawing (ink.lua). All geometry is computed in Lua and written as PDF way operators into one literal node per page; TeX does no arithmetic. Primitives are drawn in a local frame under an affine transform, which is peruse from TikZ whenever a primitive is called inside a scope. Colors arrive from a spirit ramp derived from the one document color ink: navy to mist at the hue of ink, interpolated in OKLCH so the ray end stays blue alternatively of turning gray. Tapered strokes are two offset Béziers, not sampled ribbons.

Primitives (flora.lua). Painted in the command a watercolorist would: a flat wash, darker blotches multiplied complete it, pigment pooling at the edges, streaks lifted out in white, a few fine veins, and nearly no outlines. Broad petals and flowers, celebrity lilies seen at a tilt, blossoms and florets, buds and bellflowers; lobed and complete leaves; forget-me-not cymes that curl akin a scorpion's tail, branching sprigs, umbels, tendrils, kernel heads; butterflies, bees, snails and a bird; copper sparkles, rosettes and the ivy-leaf fleuron whose stem becomes the caput rule. Any of them can be painted as a faint ghost.

Authored composition (authored.lua). A factory grows from a base in the bottom-left corner: three stems through hand-picked authority points, a fourth alongside the base of the page as the footer, leaves at chosen fractions of the stems, and all another motif on a branch that leaves its stem tangentially and arrives alongside the motif's axis — so every flower can be traced rear to the root.

Grown composition (grow.lua), in the soul of Wong, Zongker & Salesin, Computer-Generated Floral Ornament (SIGGRAPH 1998). The stems sway up the pillar as gentle noise of their height; leaves are hung at their nodes anywhere there is room. Then, repeatedly: obtain the largest liberated disc within reach of a stem, choose a motif that fits it, and develop a branch to it from the nearest stem point; the branch becomes a stem in turn. Big holes are taken first, so flowers and lilies land early, sprays and leaves inhabit the middle, and the iteration ends by tucking leaflets, buds and florets onto the stems. The end of the content is measured alongside \pagetotal in the same pass, so a abbreviated final leaf grows branches into the area below it alongside one compilation.

Reading the page (florilegium.lua). A heading or \florilegiumbloom leaves an invisible marker node in the text. When the leaf is shipped out, its box is walked node by node, adding up heights, depths and the glue as it was set, to discover all marker's height on the page; the storyline afterward gives those lines their flowers before any leaf is hung. An age reweights the motifs: buds and sprays of buds in spring, kernel heads in autumn, whenever some leaves are painted alongside a ramp built from the accent alternatively of the ink.

Initials (initial.lua). The letter's outline comes from luaotfload's OpenType audience as Bézier segments. Flattened into polygons, it gives an even-odd inner test, and a grid of distances to the letter and the example finds the largest gaps for the flowers. The vine is a Catmull-Rom curve throughout the tile; anywhere it crosses the letter it goes complete and under in turn, and the strands that go complete are drawn again, clipped to the letter, alongside a lean halo of paper.

Procedural ≠ random. The kernel is derived from the leaf number, so leaf n always gets storyline n. Reproducibility is what makes the document stable adequate to typeset.

See CLAUDE.md for a handoff-style map of the code, the tunables, and ideas not yet done.

MIT.

Geist started as a monospace typeface for developers, built for the editors and terminals anywhere they expend their day doing their work. From there it grew into Geist Sans for merchandise interfaces, and afterward into Geist Pixel, which was inspired by the grids of first device screens.

Today, we're adding a new associate to the family: Geist Serif.

Geist Serif is a high-contrast display serif built on the identical foundations as Geist Sans, Geist Mono, and Geist Pixel. It has fine, saw-toothed serifs and keen hairlines, and it was drawn to communicate messages powerfully the two in the bodily earth and on the high-density screens on contemporary devices.

Copy nexus to headingSame system, new voice

At Vercel, Geist Sans runs the product. For headlines, though, we wanted a second voice, one that belongs to the identical system, alternatively of a alien picked from a drop-down menu.

A lot of tech brands have moved distant from spotless sans-serifs to get several character back, and many of them get from vintage device ads. Geist Serif takes a distinct path: toward fashion, editorial design, and mag headlines. It's our homage to the artists rearward Rolling Stone and Harper's Bazaar.

From the beginning, all Geist family has peruse from a division of category history: the Swiss scheme movement, first terminal and DOS computing, and now editorial print.

Copy nexus to headingDisplay first

Geist Serif began as a set of sketches by Evil Rabbit, which Andrés Briganti afterward expanded. The archetypal alphabet already showed an expressive serif, in the soul of typefaces akin Victor Serif and Stanley.

When Mark Davis took complete the drawings, we made the archetypal publish a display visage for headlines, posters, and another ample sizes, during activity on the complete family continued. Print has continually struggled to clasp fine hairlines and keen serifs, but today's displays can grip a elevated flat of detail. We wanted the new visage to obtain complete advantage of contemporary screens, so we thinned all downstroke by 50% and tightened the sidebearings to shove the difference as far as it would go.

Each serif has a wedge on one flank and a curve on the other, so the proportions are traditional and appearance beautiful in print, but the building is new and optimized for digital devices.

“We created item that could lone be made for today. Not overly blocky for screens from a decade ago, not filled alongside mechanical compromises for bodily ink. Just serifs at ideal points. ”

Mark Davis originator & font decorator at WORDMARK

Copy nexus to headingFrom the archetypal prototype to today

The archetypal prototype of Geist Serif was shared on April 1, 2026. Here's the identical word, Geist, in that prototype, compared alongside the display example shipping today.

Copy nexus to headingGeist grew teeth

The goal was to regard our first intent and keep the serif closely tied to the sans, equal whenever the alphabet sit on top of all other. Geist Serif’s stems equivalent Geist Sans, and the two portion widths and postures.

The saw-toothed serifs and elevated difference provision Geist an editorial voice. One expression kept coming up as all character was drawn: “Geist grew teeth.”

Copy nexus to headingFour families, one x-height

Geist Serif uses the identical cap height and x-height as Geist Sans, so you can autumn it into any Geist layout without moving a line. Mix Sans, Mono, Pixel, and Serif in the identical declaration and all term looks the identical size.

Copy nexus to headingFour variants, one axis

Like Geist Pixel, Geist Serif has a changeable axis that swaps the form of all dot in the font, including those on i and j and in punctuation. The axis is called Element Shape (ELSH), and it gives you four variants: Regular alongside circular dots (the default), Square, Triangle (a nod to the Vercel logo), and Heart.

Each type additionally ships as its own fixed file. If you use the changeable font, choice a type alongside font-variation-settings:

Copy nexus to headingCrafted by hand

In July the font had 227 glyphs. It now has 894 and covers 352 Latin-script languages, and we worked through additional than 52,000 kerning pairs to get the spacing right. Some of the particulars are tiny. The eye of the g, for example, is tilted exactly 7°.

Copy nexus to headingSpecs at a glance

Geist Serif ships with:

• 1 importance (Regular)

• 4 variants (Regular, Square, Triangle, Heart)

• 894 glyphs

• 5 stylistic sets (ss01 to ss05)

• 352 supported languages

Copy nexus to headingGetting started

Geist Serif ships in the identical bundle as the remainder of the family:

Exports and CSS variables:

• GeistSerif (variable, all shapes): --font-geist-serif

• GeistSerifRegular: --font-geist-serif-regular

• GeistSerifSquare: --font-geist-serif-square

• GeistSerifTriangle: --font-geist-serif-triangle

• GeistSerifHeart: --font-geist-serif-heart

Each one has its own admission point, so you lone container the font document you use. For example, in layout.tsx alongside GeistSerifRegular:

import { GeistSerifRegular } from 'geist/font/serif/regular'; 
export default function RootLayout({ children }) { 
 <html lang="en" className={GeistSerifRegular.variable}> 

You can additionally download the font files, test all stylistic set, and inspect all glyph at vercel.com/font.

Copy nexus to headingWhat’s next

Regular is the archetypal manner we’re releasing, and the remainder of the family is already in progress. We’re evaluation forthcoming versions during construction this one, so this publish is fair the start.

Copy nexus to headingWeights from Thin to Black

The changeable font volition range from Thin (100) to Black (900). In this week’s proofs, the g in Black is the letter we can’t halt looking at.

Copy nexus to headingToward a content face

To examine a content version, we built a foundry tool that measures strokes, including anywhere they meet, and thickens the display outlines. It edits the outlines directly, so we can set genuine words and see which strokes need additional weight.

Copy nexus to headingItalics, built regulation by rule

We’re additionally evolving an slanted generated entirely in Python. We slanted existing italics rear upright and compared them alongside their romans. With the viewpoint removed, the remaining differences display up clearly, and we turned them into rules we can test and revise. This slanted won’t be the final version, but breaking glyphs in code helps us discover the limits faster.

Copy nexus to headingMore scripts and Google Fonts

Cyrillic assistance is planned to equivalent Geist Sans and Geist Mono, and Geist Serif volition arrive to Google Fonts following launch.

Copy nexus to headingOne family

With Geist Sans, Geist Mono, Geist Pixel, and now Geist Serif, the family runs from UI content and code to expressive display type, and all four awareness at residence together.

Download Geist Serif and commencement building.

Thank you to everyone who made Geist Serif possible.

None of this would have been imaginable without an amazing collection of group rearward the scenes.

Huge gratitude to Andrés Briganti for starting this journey alongside me and example the archetypal type that everything alternatively grew from, and to Mark Davis for carrying it throughout the complete row alongside obsessive craft, from the expanded glyph set and changeable axis to all final kerning pair. Thanks additionally to Patrick McDonald and Marijana Pavlinić for the poster designs, to Luis Gutierrez Rico for the motion and amazing magic, to Christopher Kindl for shipping the bundle and rebuilding the landing leaf downward to the smallest details, and to Zahra Jabini for the coordination and specialized assistance that brought it all together. This was a true squad effort, and I’m grateful to have built it alongside all of you.