> ## Content Index
> Fetch the complete content index at: https://devinside.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# ReadyToRun in .NET: When the JIT Replaces Precompiled Code
- URL: https://devinside.cloud/how-dotnet-runs-04-readytorun-precompiled-code/
- Published: 2026-11-20T15:00:04.000Z
- Description: Open a ReadyToRun assembly, follow a precompiled method into a later JIT tier, and weigh the file-size cost against the work left on the first request.
- Author: Marcin Borecki
- Tags: Languages, Runtimes & Performance, .NET & C#, Performance & Data, How .NET Runs Your Code, #Technology .NET, #Technology C#, #Technology ASP.NET Core, #Runtime JIT & AOT

**Series** · [How .NET Runs Your Code](https://devinside.cloud/how-dotnet-runs/), part 4 of 11\. Previous · [Why .NET compiles the same method twice](https://devinside.cloud/how-dotnet-runs-03-tiered-compilation-osr-pgo/). Next · [What does Expression.Compile run without a JIT?](https://devinside.cloud/how-dotnet-runs-05-native-aot-code-built-after-publish/)

Part 3 left Dana with an awkward choice: ask a new process to compile quickly, or spend more CPU on the first body. Ravi brings her a third candidate for Intake’s operations console. The site renders journal pages with ASP.NET Core MVC and Razor views. Microsoft lists MVC as unsupported for Native AOT, so Ravi keeps CoreCLR for this deployment. What if the publisher supplied that first body while leaving the JIT available to improve it later? [ASP.NET Core Native AOT compatibility](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot?view=aspnetcore-11.0&ref=devinside.cloud).

Ravi builds the same console twice on the Mac. One build turns on ReadyToRun (R2R), the SDK’s option for precompiling managed assemblies. The two `intake-console` launchers have identical file hashes. The neighboring `intake-console.dll` files differ. Before asking an operator to wait through a deployment, which comparison would show what Ravi’s change actually did?

.NET · macOS Arm64Read the launcher fingerprints first, then compare the byte counts of the MVC assembly beside each launcher. [Full recording](https://devinside.cloud/content/media/2026/11/how-dotnet-runs-04-s1.mp4)

- ReadyToRun puts processor instructions alongside the application's portable instructions. CoreCLR, the runtime in this build, keeps its just-in-time compiler (JIT), including on machines that can use the precompiled image.
- A fast burst of 10,000 checks finished without a new listing for the rule. Spread the same checks over a longer-lived process and the runtime compiled two further versions.
- Compiling a group of assemblies together, called composite ReadyToRun, reduced the number of compilation events through a verified API submission. It also put a new file of more than 100 million bytes in the Mac operations-console folder.
- Count what moved into the build, check the whole deployment size, then measure the operation your users wait for. An event count has no units of time.

Working solution

### Intake 4.0 · How .NET Runs Your Code, parts 1 to 11

Use the shared .NET 11 and .NET 10 solution to inspect the publish folders, reproduce the method listings, read the first-response traces and run Intake's applications. Part 4 includes `src/Part04.ReadyToRun`, the two console publish profiles and the scripts for `sizes`, `calls` and `compiled-count`. Bring Python 3.10 or later and your platform's .NET SDK. The downloadable image reader uses LLVM on the Mac and can use Capstone on Windows. The screenshot shows the same Windows assembly in ILSpy. The tagged solution built and passed its tests in Debug and Release on both hosts.

[Download the solution (zip)](https://devinside.cloud/content/files/2026/11/how-dotnet-runs-11-v9.zip)

how-dotnet-runs-11-v9.zip · 26.24 MiB (27,510,833 bytes) · tag articles/how-dotnet-runs-04-v9 · MIT license

## The framework already brings machine code to an ordinary publish

An ordinary publish leaves the application’s methods in the portable instruction format called intermediate language (IL). The application still ships alongside a runtime and libraries, including the HTTP server, JSON reader and collections that the page needs. The .NET distribution already supplies precompiled code for many of those library methods. Setting `PublishReadyToRun=false` for your project does not strip it from Microsoft's files.

Crossgen2 is the SDK compiler that adds native bodies to the application assembly. Try three fresh launches of the small `method-body` command from part 2\. Each checks 1,024 bytes and prints `allow`. Before looking at the table, predict the third count. If adding R2R to the application removed two compilations, would ignoring R2R bring just those two back?

| Application file      | Runtime choice       | JIT summary rows | What changed                                                 |
| --------------------- | -------------------- | ---------------- | ------------------------------------------------------------ |
| Ordinary              | Use available images | 2                | Main and Fits are compiled in this process.                  |
| ReadyToRun            | Use available images | 0                | Crossgen2 supplied application bodies during publish.        |
| Same ReadyToRun files | DOTNET\_ReadyToRun=0 | 640              | The runtime also loses access to precompiled library bodies. |

The first two rows isolate a *publisher* choice. The third changes a *runtime* choice across the process. Parsing an integer and printing a line still needed framework code in every row. Only in the third launch did the JIT have to provide so many of those bodies. Dana keeps the override as a diagnostic control. To decide whether to ship Ravi’s application change, she compares the first two configurations with the runtime defaults untouched. The counts are from one .NET 11 Mac run per row in `results/mac/part03/net11.0/lab-summary.json`. [Runtime compilation settings](https://learn.microsoft.com/en-us/dotnet/core/runtime-config/compilation?ref=devinside.cloud).

Dana opens the larger DLL. Added metadata or alignment padding could also explain a size increase. What would prove that a particular method acquired instructions during publish?

## One DLL contains both translations of the payload rule

Use the same method as part 2\. `Intake.Core.PayloadPolicy.Fits` accepts two signed integers and returns whether the first is within the inclusive limit. The ordinary version of `Intake.Core.dll` contains its IL. For the ReadyToRun version, ask Crossgen2 to emit a map during publish. The map ties the method's name to a **relative virtual address** (RVA), its location relative to the base address at which the operating system maps the image.

The image reader supplied with the solution opens the DLL as a Portable Executable (PE), the container format used by these managed assemblies even on the Mac. It follows the CLR header to the managed native header and checks for the ReadyToRun signature. From the map produced with that exact DLL, it locates the copied IL and the compiled method. Finally it reads those bytes from the file. The map supplies names and addresses. The DLL supplies the instructions.

Read the Windows view in that order. The eight IL bytes describe loading two arguments, testing greater than, inverting the result and returning it. The precompiled x64 body uses `ecx` and `edx` for the two arguments. The decoder obtains the comparison, conditional set and return by reading a different range in the same file. Dana has an answer even if nobody starts the program.

[![Two ILSpy panes read Fits from one DLL, showing its IL and its precompiled x64 comparison.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s2-detail-fef9109a01e4.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s2-2x.webp)

ILSpyOpen the enlarged view and match the IL return on the left with the x64 conditional set on the right. Both panes read the same assembly.

On Apple Silicon, the IL bytes are identical. The other range contains Arm64 instructions. In the next figure compare the two ranges first, then move out to `CanSubmit`, the caller in a separate assembly. Where does that caller obtain the address to which it will branch?

Code walkthrough

### The published file holds a complete rule and the caller holds a way to reach it

```text
// Intake.Core.dll · macOS Arm64 · .NET 11
Managed native header: RTR, version 26.1, flags 0x4b, sections 13
MethodDefEntryPoints     RVA 0x00033ee0 (137 bytes)

// Fits · portable IL
02 03 fe 02 16 fe 01 2a

// Fits · precompiled body · RVA 0x000120e0
stp     x29, x30, [sp, #-0x10]!
mov     x29, sp
cmp     w0, w1
cset    x0, le
ldp     x29, x30, [sp], #0x10
ret

// ready-probe.dll · CanSubmit · excerpt of precompiled caller
adrp    x11, 0x140031000
add     x11, x11, #0xaf0
mov     w1, #0x400
ldr     x16, [x11]
blr     x16
```

1. Follow the managed native header to the method entries. This names a file format and a table of locations.
2. The portable body survives the publish. A compatible runtime can still compile the original meaning of this method.
3. The mapped native body contains six instructions. Compare and conditional set implement the inclusive test on this Arm64 target.
4. The caller supplies the fixed limit and loads its branch destination from a cell. The two assemblies can meet at run time.

The two image listings and the Crossgen2 map are in `results/mac/part04`. The caller excerpt omits frame setup and return.

The course's smaller method DLL grew from 4,608 to 6,656 bytes on the Mac. The carried service application DLL grew from 33,792 to 80,896 bytes on .NET 11 and from 32,768 to 79,872 bytes on .NET 10\. Both pairs belong to specific files and releases. An extra few kilobytes in a small application assembly can be hard to see in a folder that already contains an entire runtime. Was the additional code actually used when the method was called?

## A first call can use the file and a later call can trigger the JIT

Start the ReadyToRun probe with `DOTNET_JitDisasm=Intake.Core.PayloadPolicy:Fits`. The `idle` and `once` commands isolate first use. The new `burst` and `paced` commands each cycle through 0, 1,023, 1,024 and 1,025 bytes for 10,000 checks. Both must accept exactly three in every group of four.

The one-call process answers `allow` with no JIT listing, just like the idle run. Tell the same executable to ignore its image and the filter prints `Tier0`. Disable tiering too and it prints `FullOpts`. Lesson 01 uses this control to infer precompilation. With the body now located on disk, we can ask a different question: how long will the runtime keep using it?

Part 3 showed that the runtime may compile a heavily used method again. Predict which run will first print a new body from an ordinary ReadyToRun deployment: one call, 10,000 consecutive calls, or 10,000 calls spread over a longer-lived process. Only the last run pauses between groups. All three use default tiering.

.NET · macOS Arm64The burst exits with no listing. Spacing the same number of checks lets the JIT emit two bodies for Fits. [Full recording](https://devinside.cloud/content/media/2026/11/how-dotnet-runs-04-s3.mp4)

The burst exited after 7,500 accepted checks without printing a new listing for the target. The paced run accepted exactly the same inputs but produced an `Instrumented Tier1` listing followed by `Tier1`. All three repetitions followed that pattern on macOS Arm64 and Windows x64, on both .NET 10 and .NET 11\. A precompiled first body gives the runtime something it can execute immediately. It can later gather information and publish a replacement while the process remains alive. The experiment establishes an observed sequence, not a guaranteed call count for promotion.

Timeline

### The first body can come from the DLL and a later body from this process

PublishStartFirst callLater calls NormalIgnorePaced IL + body image usable0 JIT listings skip imageTier0 image usablebody from filenew Tier1 body 

1. The ReadyToRun publish gives this method two representations. Static inspection can locate both before a process starts.
2. One call accepts the job. With a usable image the process emits no matching JIT listing for the rule.
3. Set DOTNET\_ReadyToRun to zero in a new process. At first call it compiles the IL and prints a Tier0 listing.
4. Keep precompiled code enabled and pace the work. The running process produces instrumented and optimized replacements for the original body.

The calls/calls.json files under results/mac/part04 and results/win/part04 cover both runtimes. Three fresh processes per case. The horizontal axis shows order, without a time scale.

The fast burst and the paced loop have the same count, so “this method is called 10,000 times” is a poor description of a workload. The operator's one-shot tool can exit while a long-running worker is still gathering information about its first batch. Dana keeps tiering at its defaults in the release memo. What constraints did the compiler face when it made that first, portable-across-updates version?

## A separately serviced assembly changes what its caller can assume

`CanSubmit` lives in the probe's assembly and `Fits` in `Intake.Core.dll`. Imagine the runtime could replace the latter assembly with a compatible update. A caller with the callee's exact address burned into the instruction stream would depend on the old layout. A caller that copied the callee's implementation into its own body could keep executing yesterday's rule. CoreCLR's ReadyToRun design calls a set of assemblies that can be updated together a **version bubble**. Within that set the compiler can make stronger assumptions and can inline an eligible method across a module boundary. [ReadyToRun design and version bubbles](https://github.com/dotnet/runtime/blob/v11.0.0/docs/design/coreclr/botr/readytorun-overview.md?ref=devinside.cloud).

Return to the caller in the file walkthrough. `adrp` and `add` compute a location. Then `ldr` fetches the destination stored there and `blr` branches to it. The compiler's map names this entry as a delay-load import for `Intake.Core.PayloadPolicy.Fits`. An **import cell** lets the loader and runtime bind a dependency in the process where the assemblies actually meet. The compiler does not have to know the final address at publish. Which part of that arrangement disappears when the JIT makes its own version?

Architecture

### Two assemblies can agree on the method while binding its address later

PROBE ASSEMBLY CanSubmit import cell Core · Fits call the shared rule 

1. The caller passes an integer size and the fixed limit. The policy lives in another assembly with its own identity.
2. The file names the imported method and contains a load from a cell for its native call target.
3. After binding, an indirect branch reaches the chosen implementation. An update can supply a compatible implementation at a different address.
4. Composite compilation widens the set optimized together. Our separately captured Tier1 caller still uses an indirect branch to the deliberately non-inlined method.

The precompiled-image map and both `CanSubmit` listings are in `results/mac/part04`. The mapping of the import cell is illustrative.

The later Mac Tier1 listing still contains a load and a register-indirect branch. The target is deliberately marked `NoInlining` so that there is a body to inspect. The later compiler had access to the running program and still chose this form of call. For a real application, inspect the caller whose cost matters. Counting import entries on disk cannot tell you how often any particular entry is used.

## A precompiled application still starts hundreds of compilations on one submission

The console reads the journal from a separate API. To find out what that API still compiles, start a fresh published instance, submit `{"name":"rebuild-index","bytes":1024}`, and require HTTP 202, `Location: /jobs` and a parsed acknowledgement with ID 1 and the supplied name. The page and the submission have different paths. The count below belongs specifically to that first POST.

The collector starts the runtime suspended, enables the CLR JIT events and ASP.NET Core hosting events, and resumes it. It sends exactly one request once the process announces its listening address. The server's `RequestStop` event supplies the cutoff for counting `Method/JittingStarted` events from process start. The client independently checks the response. Reject a run if it loses events or sees the wrong number of request starts or stops. A listing of the last method printed to a terminal cannot provide that same cutoff.

.NET · EventPipeThis separately recorded pair stops at the server’s first completed request. Both clients verified the acknowledgement. The comparison below uses its own ten launches per mode. [Full recording](https://devinside.cloud/content/media/2026/11/how-dotnet-runs-04-s4.mp4)

Which candidates deserve a rollout trial? Select one receiver on the newer (.NET 11) or older (.NET 10) runtime. Read the median starts from process launch through `RequestStop`. The ordinary row gives total folder bytes. Each later row prices the move from the preceding row.

Release comparison

### Wider precompilation trades a larger API folder for fewer JIT starts

Mac · .NET 11API candidateChange from the row aboveOrdinary JIT694 startsBaseline119,758,069 folder bytesIndividual R2R648 starts46 fewer starts+94,208 folder bytesComposite R2R140 starts508 fewer starts+32,247,856 folder bytes 

1. The Mac medians are 694, 648 and 140 starts. Individual precompilation adds little to this folder. The next step has a larger cost.
2. Windows has 705, 659 and 141 starts at the median. The first difference is still 46, while the cost of the composite step changes.
3. The older Mac runtime has medians of 735, 689 and 222 starts. The first-step difference persists when this runtime line changes.
4. The older Windows runtime gives 779, 733 and 310 starts. Each candidate still owes the client the same correct acknowledgement within its time budget.

Apple M3 Max and AMD EPYC 7502P. Each count is the median of ten fresh, verified first POSTs through the server’s RequestStop. Each size comes from one complete uncompressed API publish for that receiver and runtime. Changes are consecutive differences in case medians and folder bytes.

How would you compare two teams’ results if one develops on an Apple M3 Max running macOS and the other on an AMD EPYC running Windows? Compare each machine with itself first. Suppose a spreadsheet offers these three subtractions for the newer runtime. Which rows belong in Dana’s release memo?

| Ordinary baseline → individual R2R | Difference in medians | Use in the memo                                                          |
| ---------------------------------- | --------------------- | ------------------------------------------------------------------------ |
| Mac → Windows                      | 694 − 659 = 35        | Discard this comparison. Both the publish mode and the receiver changed. |
| Mac → Mac                          | 694 − 648 = 46        | Keep the Mac comparison. OS, CPU and runtime line match.                 |
| Windows → Windows                  | 705 − 659 = 46        | Keep the Windows comparison separately.                                  |

With individual ReadyToRun, the median fell by 46 JIT starts on each machine, on both runtime versions shown. Those counts end at the first request stop. To compare how long the customers waited, time the first correct acknowledgement on each receiver.

Open the first ordinary .NET 11 Mac trace and `Intake.Contracts.JobJson.get_SubmitJob` appears among the compilation starts. It supplies metadata for reading a submitted job. Of the 694 compilation-start records in that trace, 39 have method names beginning with `Intake.`. In the corresponding ReadyToRun trace, none of the 648 names has that prefix. Among them is a constructed `Dictionary` from the JSON implementation. A **generic instantiation** is a generic type or method used with particular type arguments. Precompiling a library does not produce every possible specialized body that later callers may need. Stubs and methods created at run time can also need the JIT. The retained event names let a reader inspect which explanations apply in this program.

There was a fourth control. In the ten-run .NET 11 Mac cohort, ignoring precompiled images for the whole runtime produced between 9,009 and 9,027 compilation starts. This control helps Dana locate the framework’s contribution. The next question for the three release candidates is how much precompiled code she would need to distribute.

## Composite moves work into a different file and changes the unit of deployment

Ordinary ReadyToRun lets assemblies be compiled separately. **Composite ReadyToRun** compiles a set together, allowing additional optimization and more methods to be precompiled. In the SDKs used here, this setting requires a self-contained publish. The assemblies compiled together must be deployed together. If the team services a component independently, that changes the attractive unit of deployment. [Composite ReadyToRun deployment](https://learn.microsoft.com/en-us/dotnet/core/deploying/ready-to-run?ref=devinside.cloud#composite-readytorun).

Open the Mac .NET 11 console folders. In the ordinary publish, `intake-console.dll` occupies 16,896 bytes. With individual ReadyToRun it occupies 33,792\. In the composite publish it is back to 16,896 bytes. Did the compiler undo its work? Order all files by size. `intake-console.r2r.dll` holds 100,836,864 bytes in the composite folder. Looking only at the original application DLL would reverse the conclusion.

Read these columns across. They are sums of actual uncompressed file sizes from complete console publish manifests on .NET 11\. Each row keeps one target constant. A container layer already present on a node, network compression and the base image can change transfer size. The table describes what the publisher wrote to disk.

| Operations console target | Ordinary bytes | ReadyToRun bytes | Composite bytes |
| ------------------------- | -------------- | ---------------- | --------------- |
| macOS Arm64               | 119,762,431    | 119,859,199      | 152,098,351     |
| Windows x64               | 117,094,236    | 117,201,756      | 142,528,500     |
| Linux x64                 | 111,434,599    | 111,514,983      | 138,019,879     |

On the Mac the individual application DLL doubled, yet the whole ReadyToRun console folder grew by only 96,768 bytes. Use the complete folder to budget staging space. For the API, console and CLI, `tools/part04.py sizes` lists all 54 inventories across the two runtime lines.

Keep ordinary and ReadyToRun console siblings with the same source and receiver in separate folders. In Visual Studio the sample provides both profiles for Windows x64\. For another target, pass its runtime identifier at the command line or create a separate profile.

#### One console build with R2R enabled

```xml
<PropertyGroup>
  <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>
```

A green build establishes that this option compiled. The pipeline still needs a second candidate and the first journal page an operator could use.

#### Keep both console candidates

```bash
python3 tools/part04.py build --project console --mode jit
python3 tools/part04.py build --project console --mode r2r
python3 tools/part04.py sizes --save artifacts/part04/folders.csv
```

The size command reads the series manifests. For a different version of your application, inventory its newly published folders and time its first correct page on its receiver.

[![Visual Studio shows the self-contained Release profile for win-x64 with ReadyToRun compilation enabled.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s5-detail-17abc96fde7d.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s5-2x.webp)

Visual Studio InsidersOpen the ReadyToRun profile. Read the target and deployment mode above the checked compilation option.

Which file did the compiler actually touch? In the ReadyToRun binary build log, open `_CreateR2RImages` and follow the console assembly path through `RunReadyToRunCompiler`. The log identifies the work. Its duration on a shared machine cannot price the next release.

[![The build log opens the _CreateR2RImages target, compiler task and console assembly input.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s6-detail-303660b12834_o.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s6-2x.webp)

MSBuild Structured Log ViewerExpand the compiler task and follow the relative path to intake-console.dll. This is the assembly that receives the precompiled code.

## The build host can change while the target stays fixed

Ravi can publish the Windows x64 and Linux x64 self-contained ReadyToRun folders on his Apple Silicon Mac. Each publish establishes that the target packs and compiler were available. What would show that the two receiving machines can actually run their files?

Each receiver compared its launcher, application DLL and shared core with the sender’s hashes. Then it started the API and ran all eight checks, including a valid job, two rejections and journal readback. Both targets passed. These two build-to-run paths qualify the named ReadyToRun artifacts. Part 7 tests the different build and linker requirements of Native AOT.

A runtime identifier such as `linux-x64` still leaves a hardware question open. .NET 11 raised the x64 runtime minimum to x86-64-v2\. Its Windows and Linux framework ReadyToRun code targets x86-64-v3, a higher instruction-set level. A processor can therefore run .NET 11 while lacking instructions expected by some precompiled framework code. To see what the program did rather than guess from the CPU name, the receiver ran the same Linux x64 probe under two explicit processor models with QEMU. [.NET 11 hardware requirements and ReadyToRun targets](https://learn.microsoft.com/en-us/dotnet/core/compatibility/jit/11/minimum-hardware-requirements?ref=devinside.cloud).

Both processes accepted the input. On the Nehalem model, which exposed SSE4.2 and POPCNT but no AVX2, the default run reported 450 JIT compilations. Ignoring precompiled code produced 449\. On the Haswell model with AVX2, the default summary reported zero. Its ignored-image control reported 454\. A whole-process count can vary by a few methods. What the control makes visible is the difference between using an image and falling back to run-time compilation. The emulation establishes behavior for these models. It supplies no hardware latency ranking.

The SDK also offers `PublishReadyToRunPartialAssemblies`, an item that selects assemblies for profile-driven partial compilation. That is another reason to ask which specific body a file contains. A publish setting alone cannot tell you which methods were selected or which bodies a receiver could use. The Intake comparison here used full, individual or composite publishes. [.NET SDK implementation of partial ReadyToRun](https://github.com/dotnet/sdk/pull/53635?ref=devinside.cloud).

## Choose which API builds go to the quiet receiver

For the .NET 11 rollout, suppose the platform team can reserve **140 MiB per unpacked API publish** on each test receiver. That is an illustrative release constraint of 146,800,640 bytes. The byte counts below come from measured publishes. Apply the ceiling to the *whole folder*, including runtime files. Which builds should Dana send to a quiet receiver for the first-acknowledgement trial?

__Eligibility against an illustrative 140 MiB unpacked-folder limit__
| Target      | Ordinary      | Individual R2R | Composite R2R | Composite versus 140 MiB            |
| ----------- | ------------- | -------------- | ------------- | ----------------------------------- |
| macOS Arm64 | 119,758,069 B | 119,852,277 B  | 152,100,133 B | **Over** by 5,299,493 B.            |
| Windows x64 | 117,089,523 B | 117,195,507 B  | 142,530,443 B | **Fits** with 4,270,197 B to spare. |

On the Mac the individual step adds 94,208 bytes for 46 fewer starts at the median. Composite adds another 32,247,856 bytes for 508 fewer starts and breaches the allowance. Test ordinary and individual on the Mac. All three fit on Windows. A common-mode policy excludes composite here, while target-specific modes leave it in the Windows trial.

Write the customer test on the same ticket. Start one fresh candidate on a quiet receiver, post the same job and stop the client’s clock only after it has parsed the correct acknowledgement. Interleave fresh launches of the eligible siblings and compare the first-response distributions with the product’s agreed limit. The chart counted every compilation start from process startup through the server event. A getter and a serializer each contribute one. Dividing bytes by events would tell Dana nothing about how long the customer waited.

### Give the console its own acceptance check

The web console is a candidate because an operator opens a page after deployment and MVC can stay on CoreCLR. A successful first page should include the journal and the relevant failed export. The screenshot shows what the operator needs to see. A listening socket, an empty response or an unrelated health check would all stop the experiment too soon.

[![Intake lists R&D <night> in the journal and shows partner offline under failed exports.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s7-detail-8698cf3b63cf_o.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-04-s7-2x.webp)

Google ChromeThe first page renders the journal entry in both lists, including the partner error submitted through the API.

Seed the journal and a partner failure before each fresh console launch. Time the first page that renders both correctly. The API counts belong to the POST, and the earlier console manifests describe its files. The one-shot CLI needs a correct answer and exit. The long-running worker needs its rate of correct partner deliveries after warm-up.

No quiet receiver was available for first-page latency or clean publish-duration distributions. The shared-host timing rehearsal in the companion course is a way to study the measurement procedure. The candidate decision here uses actual bytes, compilation events and verified responses. The performance decision stays open.

- Check the application DLL, its matching symbols or map, and the complete publish folder. Keep the launcher hash in context.
- Use independent publish folders, one target and identical input. Keep tiering at the deployment default for the decision run.
- Compare a precompiled image with the same image ignored to check the mechanism. Use a separately published ordinary build for the release comparison.
- Price a composite candidate as a complete unit to distribute and service. Verify the actual operation on the receiver.
- Record first page, verified response or correct tool exit at the client. Collect latency distributions on a quiet receiver before choosing a mode for speed.

For related examples, see the [measurement contract for a .NET service](https://devinside.cloud/same-service-different-numbers-a-measurement-contract-for-net/) and [an ASP.NET request that fails only after deployment](https://devinside.cloud/an-asp-net-request-that-works-locally-and-fails-after-deployment/).

## Run the controls against your published files

Start with `python3 tools/part04.py build` and `python3 tools/part04.py verify`. Windows readers can use `py -3`. Use `calls` for three repetitions and `--framework net10.0` for the second runtime. The readme in `src/Part04.ReadyToRun` shows how to inspect each file and how to build the three API candidates before running `compiled-count`. The collector starts and closes its own processes on loopback.

Lesson 01 of the companion video course uses the idle and called controls. Lesson 05 demonstrates where to put a first-response measurement. For the material specific to this article, open the map at `CanSubmit`, compare the two 10,000-call paths and look up one of the remaining generic methods in a compressed first-response report.

## Further reading

- [ReadyToRun deployment, composite images and supported cross-publish targets](https://learn.microsoft.com/en-us/dotnet/core/deploying/ready-to-run?ref=devinside.cloud)
- [CoreCLR's ReadyToRun design and version bubbles](https://github.com/dotnet/runtime/blob/v11.0.0/docs/design/coreclr/botr/readytorun-overview.md?ref=devinside.cloud)
- [The ReadyToRun header and section definitions](https://github.com/dotnet/runtime/blob/v11.0.0/src/coreclr/inc/readytorun.h?ref=devinside.cloud)
- [How tiered compilation changes a running method](https://github.com/dotnet/runtime/blob/v11.0.0/docs/design/features/tiered-compilation.md?ref=devinside.cloud)
- [ASP.NET Core's request start and stop events](https://github.com/dotnet/aspnetcore/blob/v11.0.0/src/Hosting/Hosting/src/Internal/HostingEventSource.cs?ref=devinside.cloud)
- [Minimum hardware requirements and precompiled targets in .NET 11](https://learn.microsoft.com/en-us/dotnet/core/compatibility/jit/11/minimum-hardware-requirements?ref=devinside.cloud)

Dana keeps ordinary and ReadyToRun console candidates with matching page checks and a measured size difference. Composite earns a separate row in the experiment because the whole set ships together. The CLI still needs time to useful exit, and the worker still needs a reason to spend extra bytes on startup.

ReadyToRun left the JIT available for an operation the build did not foresee. Lena's worker builds a customer rule from an expression tree after launch. If its native publish has no JIT, what actually executes that rule?

**Series** · [How .NET Runs Your Code](https://devinside.cloud/how-dotnet-runs/), part 4 of 11\. Previous · [Why .NET compiles the same method twice](https://devinside.cloud/how-dotnet-runs-03-tiered-compilation-osr-pgo/). Next · [What does Expression.Compile run without a JIT?](https://devinside.cloud/how-dotnet-runs-05-native-aot-code-built-after-publish/)