~/satyajit

xeet: an X post drawn without a browser, and what "pixel-perfect" is checked against

mdjsonmcp

2026-11-16 · 23 min · rust · webassembly · fonts · agentic-coding · developer-tools

A 2:41 narrated explainer, drawn in code. Every number and picture in it is this article's own; the sources are below.

› transcript

Every frame of this game is an X post. No browser drew any of them. Two hundred and forty-one frames in two hundred and sixty milliseconds. This is xeet, a post renderer Guillermo Rauch released this week. Hi, I'm Pica. Where a post's lines break is a browser's decision. xeet copies that decision instead of asking a browser to make it. First, X's own rules decide which text shows at all: hidden reply mentions, shortened links, and where Show more cuts. Every character then gets a face. One of twenty-eight Chirp files if it has the glyph, then Arial, Apple's emoji, and stand-ins for the Mac's fallbacks. Each run is shaped by the Rust port of HarfBuzz, with advances converted the way Chrome converts them. Then the line is fitted, exactly the way Blink fits it. And it is painted with sixty-four sub-rows per pixel, and Apple's own emoji bitmaps. Words go onto the line one break at a time. Each candidate end is measured, and the first one past the edge stops the search. Blink counts in sixty-fourths of a pixel. A width is rounded up to the next one before it is compared. A line one unit wider than its box still fits if it ends before a space, and not after a hyphen. The authors measured that on six hundred probes. Then the line is shaped again on its own. Kerning across the break is gone, so it may not fit any more, and the loop steps back a word. The engine is a module of under three megabytes over the wire. The fonts are the cost: one emoji pulls in Apple's emoji font, and the demo preloads every pack. Here is one post on two surfaces. On the left, X's own embed, in the system font with Twemoji. On the right, xeet's timeline, in Chirp with Apple's emoji. Different sizes, but both cut the text at the same word. To check line breaks, I rebuilt a Chrome oracle with Chirp loaded and compared fifteen layouts. Fourteen matched. One did not: a Japanese post, eight lines in xeet and nine in Chrome. Handed xeet's own font files, Chrome agrees with it exactly. With the Mac's own fallback, the kanji come from a Chinese font, and one line is a third of a pixel too wide. Pixel-perfect is a subscription, not a milestone. xeet is Chrome's text arithmetic, copied and checked. Past Chirp and Apple's emoji, the match depends on which fonts the Mac has. Blink's fitting, in Rust. It matches Chrome when the fonts match. Use it to check drafts, not to embed posts. Every source is in the full article. I'm Pica. Bye!

Why read this

Notabletop 60%

xeet's wasm driven on real posts and weighed byte by byte; its Chrome oracle rebuilt, and the one Japanese line where system fonts and xeet's fonts disagree.

  • Original analysis
  • Runs in a browser
  • A new technique

Developer tools & infraMixed licencesPractitioner tool

How this was scored
Is it new?
2 of 3: A real new idea, method or capability
Can I trust it?
2 of 3: Measures key facts from files, code or configs
Can I run it?
2 of 3: Open code or weights with real limits
Will I understand it?
2 of 3: Mechanism from first principles with figures
Can I act on it?
2 of 3: A concrete recipe, numbers or comparison
Will it last?
1 of 3: Relevant for months
Does it affect many?
1 of 3: A specialist community
Only here?
2 of 3: A teardown or measurement few others did

Score 64 of 100, ranked 320 of 748 rated articles. Each question is answered 0–3 by hand, and a 3 is rare. How articles are scored

On 16 November Guillermo Rauch posted xeet: "a hermetic, pixel-perfect X post renderer in safe Rust / wasm. Zero browser, network, filesystem, system fonts. Renders a post to PNG in ~1ms." The code is at github.com/rauchg/xeet (Apache-2.0 for the code, with a separate note about the fonts that matters later), and a playground runs the WebAssembly build at xeet-rs.vercel.app.

The README's framing is that most preview tools boot headless Chromium, load a page, and take a screenshot. That costs a browser process and hundreds of milliseconds. xeet's bet is that a post only depends on a small part of the browser: X's client rules, text shaping, line breaking, a flexbox frame and an anti-aliased rasterizer. Rebuild exactly that part, prove it matches Chrome, and the screenshot becomes a function call.

I read the repository at commit 71079ff1, ran its WebAssembly from the live site inside headless Chromium on five posts, measured what it downloads, and rebuilt its Chrome oracle to check one result that came out wrong. The post's own video first.

The launch film's opening: the same render from the CLI, TypeScript and Rust, each with its output beside it. The timings drawn on screen are the authors' (video from @rauchg's post on X).

What "hermetic" means in the code

The renderer is the crate xeet-core, and it does no I/O at all. It takes a Post (only text is required) and RenderOptions (surface, width, theme, device pixel ratio), and returns PNG bytes plus a Report. The four library crates (xeet-core, xeet-text, xeet-resolve, xeet-resolve-net) start with #![forbid(unsafe_code)]. xeet-wasm denies it everywhere except the wasm-bindgen glue module, whose generated shims need unsafe, and tools/ship/check-unsafe.mjs checks that nothing else opts out.

The network lives in a separate crate, xeet-resolve, which turns a pasted x.com URL into a Post. Even that one does not own a socket: the caller passes in Fetch, Lookup, Cache and Clock implementations. It crawls t.co as Twitterbot/1.0 (the README notes that t.co answers that user agent with a 301 and browsers with an interstitial), follows redirects by hand up to 10 hops, honours robots.txt, and refuses private, loopback and cloud-metadata addresses on every DNS hop. The README states that the native and WASM builds produce byte-identical PNGs, with matching SHA-256 hashes on 24 of 24 cases.

So "zero network" is true of rendering. "Zero system fonts" is true too, but the fonts have to come from somewhere, and that is where the size goes.

Where the bytes go

crates/xeet-core/build.rs embeds fonts with include_bytes!. With XEET_FONT_PACKS=core, which the WebAssembly build sets, only X's own font, Chirp, and Arial go into the module. Everything else becomes a pack that the host fetches and registers before rendering text that needs it: emoji, cjk, math, latin, arabic, hebrew. The native CLI embeds every face, about 49 MB according to docs/PERF.md.

I downloaded the live module three times, once per encoding. It is 6,455,325 bytes raw, 2,866,768 gzipped and 2,720,342 with brotli, which agrees with PERF.md's "6.44 MB raw / 2.85 MB gzipped". Walking the module's section headers gives 2,951,775 bytes of code across 3,663 functions, a 3,008,585-byte data section, and a 484,169-byte name section, debug names a renderer never reads. To see what the data section holds, I searched the module for the first and last 4 KiB of every font file in the repository. The 28 Chirp .ttf subsets (4 weights × 7 Unicode ranges, 551,160 bytes) and Arial regular and bold (1,521,640 bytes) are in it, 2,072,800 bytes together. No other font is.

The packs are listed in packs.json with a SHA-256 each, and the loader checks it before registering a file. They come to 39,158,596 bytes raw, or 33,502,218 with brotli. Emoji alone is 20,930,352 bytes, because it is Apple Color Emoji, whose glyphs are PNG bitmaps in an sbix table that brotli can shrink by only 4%.

The widget's point is the asymmetry. A post in Latin script costs the module and nothing else: 2.72 MB on the wire. One emoji adds 20 MB. The playground does not wait to find out which packs a post needs. app/_lib/wasm.js calls preloadFonts as soon as the module is ready, and that calls prefetchAll, which starts all six. I logged the requests on a fresh load: all six packs were requested within a second of the page loading, and the emoji pack finished at 2.7 s. A visitor who never types an emoji still downloads Apple's emoji font: 36.2 MB on the wire in all, counting the module. That is a demo's choice (a carousel slide never waits for a pack), not the library's: ensureFonts loads only what a post asks for.

The xeet playground page. A serif heading 'xeet', a one-line description, three bullet points (X's own rules; small and fast, a WebAssembly core under 3 MB compressed; checked against Chrome, zero line-break differences across 13,440 text layouts), then an Examples carousel at 1 of 17 with an input holding https://x.com/jack/status/20, and three renders of jack's post at timeline 390, detail 390 and timeline 600, labelled 17.4 ms, 4.5 ms and 1.5 ms.
The playground in my headless Chromium run: four PNGs of jack's first post, 1.5 to 17.4 ms each, the slow one being the first render after load (screenshot of xeet-rs.vercel.app, 16 November 2026).

Laying out text without a browser

The hard part of drawing a post is the paragraph. Chrome decides where lines break, and if you are a third of a pixel off, a word moves to the next line, the post gets 20 px taller, and "Show more" lands somewhere else. The README lists what xeet reproduces, and the code bears it out. In the order a paragraph goes through it:

  1. Rules first. X's client decides what text is visible at all: reply mentions are hidden, a trailing status URL becomes a quote card, links display shortened. xeet-text reimplements the open-source twitter-text rules and the README says it passes all 2,119 of that project's conformance cases. The ruleset lives in crates/xeet-core/rules/x-web.json, each rule marked as read from X's shipped JavaScript, measured on captured payloads, or a prior.
  2. Runs. UAX #9 bidi levels from unicode-bidi, then script runs the way Blink's ScriptRunIterator cuts them.
  3. A face per character. fonts.rs walks X's font stack per character: Chirp first if any of its 28 files has the glyph in its CSS unicode-range, then Arial, Apple Color Emoji, and stand-ins for the Mac's system fallbacks (Hiragino Sans, STIX Two Math, Noto). Variation selectors decide © (text, Chirp) against ©️ (emoji).
  4. Shaping. harfrust, the Rust port of HarfBuzz, shapes each run. Chrome receives a glyph's own advance from its font backend as a float truncated to 1/65536 px, while HarfBuzz scales kerning with rounding, so shape.rs converts both in 16.16 fixed point. The comment says why: the difference "decides lines whose width lands within 1/65536 px of the box edge".
  5. Break opportunities. Between two ASCII characters Chrome uses its own pair table instead of Unicode's rules; linebreak.rs carries that table (regenerated from Chrome by tools/oracle/breaks.mjs) and falls back to ICU4X's UAX #14 segmenter for everything else.
  6. Fitting. Here Blink's integer arithmetic matters. Widths are snapped up to Blink's layout unit, 1/64 px, and a line ending at a space gets exactly one unit of slack:
// crates/xeet-core/src/inline.rs
fn ceil64(w: f32) -> f32 {
    (w * 64.0).ceil() / 64.0
}
 
fn fits(width: f32, avail: f32, at_space: bool) -> bool {
    const UNIT: f32 = 1.0 / 64.0;
    ceil64(width) <= avail + if at_space { UNIT } else { 0.0 }
}

The comment above it says the rule was measured over 600 probes with tools/oracle/fit-threshold.mjs: "a 240.015625 px line fits a 240 px box when it ends before a space, and not when it ends after a hyphen."

The loop that uses it, layout_hard_line, has one more Chrome quirk in it. It finds the furthest break that fits using widths measured inside the whole paragraph, then shapes that line again on its own, because Chrome re-shapes the line end and kerning across the break disappears. If the re-shaped line no longer fits, it steps back one opportunity at a time. If nothing fits, it breaks inside the word.

The widget runs that loop on a sentence from the post, with one honest substitution: the widths are your browser's sans-serif measured with canvas measureText, not Chirp, so the breaks are not X's. The arithmetic is xeet's. Drag the width by a quarter pixel and you can watch a word jump lines when its rounded width crosses the limit.

  1. Paint. paint/coverage.rs replaces tiny-skia's path anti-aliasing (four sub-samples per row, 16 coverage levels) with exact span overlap over 64 sub-rows per pixel, which the README says lands within 4/255 of the analytic area on a circle. Glyph outlines come from skrifa, unhinted, quantized to Skia's 1/4 px subpixel grid, with the baseline snapped to a whole CSS pixel as Blink does. Emoji are the sbix PNG strikes from Apple's font, placed at CoreText's em box and resampled with a premultiplied tent filter.

That is a lot of Chrome to copy, and none of it is guessed: almost every constant in those files has a comment naming the oracle script that measured it.

NASA Goddard's post from November 2017 rendered by xeet: scattered stars, dots and emoji (a glowing star, a crescent moon, a satellite, sparkles, the Earth, a sun, a comet) laid out with runs of spaces across several lines, the line 'Thanks @Twitter, we can always use more space' with a rocket, and the hashtag #280characters, above counts of 880 replies, 109K reposts and 251K likes.
One of the four posts the project uses to break renderers: NASA Goddard's 2017 space field, where runs of preserved spaces and emoji widths are the layout (xeet's own render, from the gallery in the rauchg/xeet README).

What "pixel-perfect" is checked against

xeet's tests compare every layer against something that is not xeet, and the authors are careful about what they commit: X's post text and screenshots stay in a private store, and only counts, deltas and hashes are in the repository. Three of the checks are worth reading closely.

Text against Chrome. tools/oracle/text-parity.mjs lays strings out in headless Chrome, inside the exact element X uses for post text with X's real stylesheet, and in xeet, and compares line by line. The README reports 0 line-break and 0 height mismatches across 13,440 layouts. The post's "tens of thousands of text layout rules" is presumably that, plus the 2,119 twitter-text cases and 3,029 more checked against X's client code: 18,588 in all. What CI can re-check without Chrome is smaller, tests/golden/text.json: 210 synthetic strings at six widths, 1,260 layouts. And the script that captures it says something the README does not. In tools/ship/golden-capture.mjs, the styled and emoji coverage sets are left out because they "still disagree with Chrome on line breaks", with the line "A golden records agreement we have, not agreement we want." One of the two documents is out of date. Either way, the golden that gates every push covers fuzzed and whitespace-heavy text, not emoji.

Whole posts against captured pages. tools/ship/e2e.mjs renders each post embedded in saved x.com pages and compares it with Chrome rendering that page. tests/golden/e2e.json records 159 compared, 159 passed, and 124 skipped (cards whose metadata the capture lacks, pinned rows, image-only posts). A pass means: height within 1 px, identical line breaks, and the share of pixels differing under the platform's budget, which is 3% on macOS. A pixel counts as differing only if it is more than 8 levels off in some channel and no neighbour within one pixel matches; the screenshot is taken with font smoothing forced to greyscale, and image rectangles are masked out, since Chrome gets a blank stub there. A post with an emoji that misses the budget is recorded as raster:emoji and not failed, under a comment that reads "Apple's emoji font cannot be shipped, so we draw Twemoji", which the paint code no longer does: it draws Apple's. From the committed golden I get a median pixel share of 1.41% and a maximum of 2.81% across the 159; 70 of them have a nonzero height difference, up to 0.97 px. The harness's own comment explains the 3%: it is the measured worst case, 2.809%, "with nothing to spare". On Linux the target is 0.5%. So "pixel-perfect" means "line-perfect, within a pixel of height, and within the anti-aliasing gap between two rasterizers", which is what a careful engineer means and not what the phrase says.

Font choice against a Mac. The header of fonts.rs is the most candid paragraph in the repository. Over 6,376 code points, characters Chrome draws with Chirp, Arial, the emoji font or STIX agree with xeet on family and advance 94% of the time. Characters Chrome gives to a Mac system font that cannot be bundled keep that device's advances, and xeet matches those only about 7% of the time; "★", "✈" and "♥" are named. The web target is Chrome on a Mac (there are also iOS surfaces, measured from iPhone captures). A post seen in Chrome on Windows, on Android, or in X's own embed is drawn differently, and xeet makes no claim about those.

What I ran, and where it differed

xeet's resolve endpoint on the demo refuses automated requests ("automated requests are not allowed"), and x.com itself rendered an empty page to headless Chromium, so I could not compare against X's own timeline. Instead, I built five Post objects from the fxtwitter mirror's data (text, author, avatar bytes, counts, and the video's size and duration), opened the live demo in headless Chromium 158 on an Apple-silicon Mac, imported its xeet_wasm.js, registered all six packs, and called the module directly. Four posts are real: jack's first post, Rauch's launch post, a Japanese post by @okhotskuma with full-width punctuation, and a Japanese post by @ymt3d with a long link and a hashtag. The fifth is mine: a long URL, a ZWJ emoji, two flags, Japanese and Arabic in one line.

Timings, 30 renders each after a warm-up, median, at a 390 px timeline width and device pixel ratio 2, PNG encoding included:

postrenderwhat is in it
jack, 24 characters1.1 msan avatar
the stress line1.0 msdefault avatar, emoji, CJK, Arabic
okhotskuma1.9 msavatar, 8 lines of Japanese
ymt3d5.3 msavatar, 9 lines, a video placeholder
Rauch's launch post5.6 msavatar, Show more, a video placeholder

The same launch post at the 600 px detail width, expanded to all 25 lines, took 16.7 ms. The browser rounds performance.now() here to 0.1 ms, so the small numbers carry about that much error, and explain (layout without pixels) came in at or near that floor. The post's "~1ms" holds for short text posts, in this setup. The README's own figure is 2.8 ms median for a text post at 390 px and 3× density, measured natively; the film's Tetris segment, where every frame is a post, shows 1.0 to 1.4 ms per frame at 382 px, natively. A post with media is several milliseconds, and PERF.md says four real 800×600 photos take 62 ms, twice the 30 ms budget its table sets.

Tetris played as a sequence of posts, each frame rendered by xeet natively, ending on 241 frames in 260 ms. The timings are the authors', from the native build, not the browser (video from @rauchg's post on X).

The output is right in the places I could check against X's own data. The link in the ymt3d post displays as 3dnchu.com/archives/spiru…, which is exactly the display string X's API returns for it. Rauch's post is cut at "X is the global town square, and the" with Show more, and X's embed of the same post cuts at the same word. Counts abbreviate as X does (1.2K, 57K). xeet's report gives the weighted length X's composer would count: 263 of 280 for the okhotskuma post, because each Japanese character costs 2, and 1,127 for Rauch's long post, which is a premium account's post and flagged as over the standard limit.

Two renderings of the same post side by side. Left: X's embed widget, with the text 'Introducing xeet: xeet-rs.vercel.app. A hermetic, pixel-perfect X post renderer in safe Rust / wasm...' in a system font at a larger size, a Twemoji grin, 'Show more' inline after 'and the', a black video box with a play button, '1.2K' likes and 'Read 146 replies'. Right: xeet's timeline render at 390 px, in Chirp at a smaller size, an Apple emoji grin, 'Show more' on its own line, a grey video placeholder with a 00:37 pill, and counts 146, 68, 1.2K and 57K.
The same post on two surfaces, so different fonts and sizes are expected. Left, X's embed widget: system font at 20 px, Twemoji images, a 516 px text column. Right, xeet's web timeline at 390 px: Chirp at 15 px, Apple emoji, a 310 px column. Both cut the text at the same word (my screenshots, 16 November 2026).

For line breaks I needed Chrome laying out the same text with the same fonts. I wrote a small oracle: xeet's own visible text from its report, set in Chrome with Chirp loaded from the repository's .woff2 files under the manifest's unicode-ranges, at X's 15/20 px timeline type in a 310 px column (the 390 px frame minus 16 px padding each side, the 40 px avatar and its 8 px gap), and at 240 px and the 568 px detail column. Line counts agreed on 14 of 15 layouts. That is a count, not a comparison of where each break falls, so two errors that cancel would pass.

The 15th was the okhotskuma post at 390 px: xeet draws 8 lines and Chrome drew 9. Chrome broke the fourth line one kana earlier, after マッチングっ. Measured on its own, SpirulaStudioで成功。LoMaのマッチングって is 310.33 px in Chrome, a third of a pixel too wide for the column. To see whose fault that is, I rebuilt the project's own harness in place of mine: X's real stylesheet (fetched from the URL pinned in assets/upstream.lock.json), the element and classes text-parity.mjs uses, both of its fallback modes, and a third run with the text marked Japanese, sweeping the column from 308 to 312 px:

fallbackfonts Chrome used for the Japaneselines at 310 px8 lines from
bundled (xeet's own font files)Hiragino Sans from the repo8310 px
system (this Mac's fonts)Hiragino Sans for 89 glyphs, PingFang SC for 279312 px
system, with lang="ja" on the textHiragino Kaku Gothic ProN for all of it9310.5 px

With xeet's fonts, Chrome agrees with xeet exactly, flipping between 309.5 and 310 px. With the Mac's own fallback and the oracle's lang="en" page, Chrome draws 27 glyphs (all 25 kanji and two punctuation marks) from PingFang SC, the Chinese system font; I checked by querying the font used for a kanji-only span. Those glyphs have different advances, and the line no longer fits. So xeet's engine is right; the question is which fonts the real page uses. X marks post text with its language: in X's embed of this post the tweetText element carries lang="ja", which I checked. With that attribute under X's stylesheet, Chrome on this Mac uses Hiragino Kaku Gothic ProN, a third family, for every Japanese character, and still draws 9 lines at 310 px; it needs half a pixel more. I did not see this post on x.com, so what a Mac reader gets there is unverified, but both system-font runs disagree with xeet. What it does show is the limit the fonts.rs header already admits: past Chirp, Arial and the emoji font, "pixel-perfect" depends on which system font Chrome picks, and xeet can only bundle one.

Three posts rendered by xeet at 390 px. Left: Toshiaki Kumaki's Japanese post about 4,066 panoramic images and SpirulaStudio, eight lines with full-width brackets and a trailing ellipsis, his name truncated with an ellipsis. Middle: 3D人-3dnchu's Japanese post recommending Spirula Studio, with the link shown as 3dnchu.com/archives/spiru… and the hashtag #3DGS in blue, above a grey video placeholder with a 00:14 pill. Right: a test post reading 'Long link: example.com/a/really/long/…' followed by a technologist emoji with a skin tone, a rainbow flag, a Japanese flag, Japanese text and right-to-left Arabic.
xeet's renders of the two Japanese posts and my stress line: long names and links are cut with an ellipsis, a ZWJ emoji and flags draw as single glyphs, and the Arabic runs right to left. The left one is the post whose line count differs from Chrome with system fonts (xeet's live WebAssembly, driven by me in headless Chromium).

The autorepo, a day in

Rauch calls xeet an "autorepo": an oracle checks the port against Chrome, and "a CI canary then watches the evolution of the original, and files signed PRs for agents to act on." docs/CI.md describes it. upstream-watch.yml runs every six hours, probes logged-out x.com's stylesheet and server-rendered markup, and either opens an alarm issue or dispatches sync.yml. That one snapshots upstream, regenerates the design tokens, runs the gates, and ends in either a pull request committed through GitHub's createCommitOnBranch (so GitHub signs it) or "a repair-brief issue", which the workflow describes as "the brief an agent picks up". CI.md is upfront that this pipeline "is a skeleton with real seams" and that some policy decisions are still manual. As of this writing the repository has no pull requests at all, signed or otherwise; the canary's only output so far is an issue. Pull requests never run CI, so fork code never touches a runner.

The canary has already fired. Issue #1, opened by github-actions[bot] at 00:46 UTC on launch day, reports 22 of 23 checks passing, X's app version rotated from the pinned 89824c04 to ec61450c, a new stylesheet hash, and one failure: fetching a profile page returned HTTP 403 from the CI runner. The most recent commit at the time I cloned is a fix for exactly that ("Fall back to live x-web bundle when profile SSR returns 403 on CI runners"). The public history starts with an "initial commit" on 16 November, so the history of the agents' work is not visible. One loose end: the README describes the ruleset as x-web@55591fe0, while the live module reports 89824c04… as its upstream; SPEC.md lists both as captured app versions.

A reply under the post put the cost plainly: pixel-perfect against X "is a subscription, not a milestone". X has already shipped a new stylesheet since the pin. The project's answer is the canary plus agents to do the port, and the verdict on that answer is months away.

The fonts it ships

The repository commits AppleColorEmoji.ttf, the two Hiragino Sans files, Arial and Chirp under assets/vendor/fonts/ (the comment at the top of build.rs still says they are "deliberately not committed"). The README's licence section says those fonts "remain under their respective upstream terms and are not covered by the Apache-2.0 license", and tells you to redistribute binaries "only with fonts you are licensed to ship". Apple's fonts are licensed for Apple devices, and Chirp is X's. The public demo serves the emoji and Hiragino packs to every visitor anyway. I am not a lawyer, and the authors flag this themselves, but it decides what anyone else can deploy: the engine is Apache-2.0, and the thing that makes it match a Mac is not yours to ship.

Would this site use it?

This site does not render X posts today. I checked components/ and lib/: there is no embed component, no react-tweet, no iframe. Articles link a post, credit its author, and embed the post's own images and videos as files on our media bucket. The one place a post appears as a picture is a screenshot, as in the Modern Web Guidance piece.

So the question is whether xeet would be a better way to show a cited post. I don't think it would, for three reasons that stand on their own.

Where it would help is one step earlier, in the /amplify drafts. The amplifier writes X threads into drafts/<date>/<slug>/x-thread.md and nothing checks their length the way X counts it: a URL is 23, an emoji or a CJK character is 2. xeet explain returns exactly that (length.weighted, length.valid) plus where Show more would cut on the web timeline and on iOS, with no pixels and in well under a millisecond. Run as the CLI over each draft before Satyajit approves it, it answers the questions the post was written for: does this fit, and where does it fold. That is a tool run on a draft, so it can run on a server away from the site, and it ships no fonts.

What was run and what was only read

Read: the repository at 71079ff1 (README, SPEC.md, docs/PERF.md, docs/CI.md, docs/E2E.md, tests/golden/*, build.rs, fonts.rs, shape.rs, linebreak.rs, inline.rs, tools/oracle/*, tools/ship/*), issue #1 and the commit list through the GitHub API, the post and its replies through the fxtwitter mirror. Ran, on an Apple-silicon Mac: the live module in headless Chromium 158 on five posts (timings, reports, PNGs), byte counts of the module and packs in three encodings, a section walk of the module, a search for each font file inside it, X's embed widget for four posts, and two Chrome oracles (mine, and a rebuild of the project's text-parity.mjs setup) on xeet's visible text. Not run: xeet's own test suite or oracle, and anything natively; the project's pinned Chrome is 141 and mine was 158. Not seen: any post on logged-in x.com.

Related reading here: what an agent's web-font advice is worth on three real fonts, fframes, where a frame is also a function, and three harnesses read for how they check an agent's work.

Cite this article

For attribution, please use the following reference or BibTeX:

Satyajit Ghana, "xeet: an X post drawn without a browser, and what "pixel-perfect" is checked against", ai.satyajit.si, November 2026.

bibtex
@misc{ghana2026xeet,
  author = {Satyajit Ghana},
  title  = {xeet: an X post drawn without a browser, and what "pixel-perfect" is checked against},
  url    = {https://ai.satyajit.si/articles/xeet},
  year   = {2026}
}
share