Build1 distinct publisher2 min readPublished
Turbopack decides which chunks to merge by looking only at chunks a page already loads together, which bounds the worst case but leaves the returning visitor re-downloading shared code the merged file no longer fits.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Do the arithmetic on the two-page session. Call A the footer's chunk, used on every page, and B the video player's chunk, used only on the home page; both sit in the home page's chunk group, so both are merge candidates [12]. Unmerged, the home page fetches A and B, two requests, and the legal page fetches nothing new because A is cached. Merged, the home page fetches AB in a single request [13], and the legal page needs A, cannot use the merged file, and downloads A on its own [14]. Same request count on both paths, plus one extra copy of the footer on the merged one [17].
So the merge is a bet on how the session ends. It always wins if the visitor loads one page and leaves [13]. Across a navigation it pays only when both pages need both chunks, and then the merged file is reused and a request is saved [15]. The same reasoning extends to sessions of three or more visits [16], where the number of ways a merged file can turn out to be the wrong shape only grows.
The containment is the part worth praising. Merging is restricted to chunks in the same group, and a group is by definition loaded together, so a merge cannot add a byte the page was not already fetching [11]. Over-shipping, the failure that ruled out the one-chunk-for-everything approach [4], is unreachable by construction. What is left is redundancy on later navigations, which is bounded and measurable.
The per-module option is the one that gets underestimated. It over-ships nothing and downloads a shared module once [6], but gzip can only find repeated patterns within a single file, so the same bytes split across hundreds of files compress worse, and according to nextjs.org compression dictionaries help without solving it [7]. Fewer requests and less code do not both arrive; bigger chunks cut requests and lose reusability across pages [8].
Where the reasoning runs out matters for anyone hoping to tune this. nextjs.org names the hard part as deciding which chunks to merge and when merging is truly beneficial [9], and the text available breaks off at "Here are the other poss", before those remaining cases, with no size threshold and no configuration flag for the merge decision in it [19]. What the post supports is a diagnosis, not a setting. When a route feels heavy, the question the design points at is which of its chunks are shared with the pages visitors open next, because across a navigation that is the only thing the merge decision keys on [15].
Ranked by verification strength, evidence, and original report placement.
Turbopack's analysis considers two kinds of visit, one where the visitor loads a page and leaves and one where the visitor navigates to a second page, and the same analysis extends to sessions with three or more page visits.
Turbopack generates dozens of chunks for a Next.js app, holding the app's own code, the packages it depends on, and the runtime that wires it all together.
A Turbopack chunk is a push onto a globalThis.TURBOPACK array containing numbered module entries (for example 7284 and 395264) and ends with a debugId comment.
With one chunk containing all the app's JavaScript, every load after the first is a cache hit and navigation is fast, but a page with little or no JavaScript still loads the JavaScript for every other page, so every page load gets heavier as the site grows and the approach is not feasible in the long run.
With one chunk per page, chunks stay slim and code is never over-shipped, but caching is lost: a Footer used on every page ends up inside every page's chunk, so a visitor who opens four pages downloads the same footer code four times.
Giving every module its own chunk means nothing is over-shipped and a module shared between pages downloads only once, but it produces hundreds of network requests for tiny JavaScript files, each carrying overhead; HTTP/2 made requests cheaper but each request still carries overhead.
Distinct publishers with included, body-backed reporting in this cluster.
1 article · September 4, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
Tailwind v4 moves your tokens into CSS. The token name is now the API.1 distinct publisher
build
Next.js 'use cache' claims 700ms TTFB down to 60ms. Every deploy hands the bill back1 distinct publisher
build
Next.js's architecture is working. Its operating manual isn't keeping up.1 distinct publisher
build
Only crossing the ES module line changes what Next.js 16 emits1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
One account, checkable in its first half
Anyone can reproduce the front half of this post. The chunk envelope, the module ids, the debugId line are visible in a browser, and the Footer-and-VideoPlayer arithmetic follows from the example without trusting anyone. The empirical half travels less well: the per-scenario table and the three-configuration comparison are figures and assertions from the team that wrote the bundler, gathered on one site with one navigation script.
Default on one site, measured by its owner
The behaviour already decides what nextjs.org ships, which is more than a proposal, and the comparison treats default merging as the baseline. It is still one production site instrumented by its own maintainers: no other deployment, no independent bundle audit, and no indication of how many Next.js apps run these defaults untouched.
Reads under its own findings
The unflattering cases are in the text rather than missing from it: the home-to-legal walkthrough concedes the Footer chunk crosses the wire twice, the comparison concedes maximum merging shipped about 10% more code, and the two-thirds session split is labelled an estimate. A team with these numbers could have written something considerably louder.
The bundler's authors grading the bundler
The Next.js blog is explaining a choice the Next.js team made, benchmarked on the Next.js homepage, with the author picking both the configurations compared and the navigation sequence run against each. None of that is concealed. But the thresholds that actually govern merging go unnamed, which leaves a reader unable to re-run the comparison or move the default.
Trust the mechanism, discount the numbers
Bounding merges to a chunk group is a structural guarantee rather than a measurement, and the two-visit accounting is arithmetic a reader can redo, so the mechanism is safe to reason about. The figures deserve less weight: one site, one author, tables delivered as images, and available text that stops mid-sentence just before the new chunking features it was introducing.