---
name: apple-tv-4k-budgets
description: Measured performance budgets for Apple TV 4K (A12, A15, A19 chips) on tvOS — what fits in a 60 Hz frame at 1080p, 1440p and 2160p, how much each chip loses to heat over 20 minutes, the per-app memory limit, MetalFX upscaling costs, CPU figures, and lessons for testing on real Apple TV hardware. Use when building or tuning a tvOS app or game, choosing quality tiers per Apple TV model, picking a render resolution, sizing memory, or automating runs on Apple TVs with devicectl.
---

# Apple TV 4K performance budgets (A12 · A15 · A19)

Measured budgets for building tvOS apps and games that must run at 60 Hz on all three Apple TV 4K chips. Pack version 1.0, data generated 2026-11-16, tvOS 27.2 and 27.2.1. Sample: one A12, one A15, two A19 units, measured by one developer with his own Metal test app; single units, so treat every figure as ±5 % at best. A `*` marks a figure from fewer than three repeats.

**Use this when** building or tuning a tvOS app or game, choosing quality tiers per Apple TV model, deciding a render resolution or whether to upscale, sizing memory use, or automating runs on real Apple TV hardware. The full tables are in `budgets.json` next to this file.

## 1. Tell the boxes apart at run time

|  | A12 | A15 | A19 |
|---|---|---|---|
| `hw.machine` / model id | `AppleTV11,1` | `AppleTV14,1` | `AppleTV18,1` |
| `MTLDevice.name` | Apple A12 GPU | Apple A15 GPU | Apple A19 GPU |
| highest Metal GPU family | apple5 | apple8 | apple10 |
| CPU cores (performance + efficiency) | 6 (2 + 4) | 5 (2 + 3) | 5 (2 + 3) |
| physical memory, GiB | 2.9 | 3.9 | 7.9 |
| Metal 3 / Metal 4 | no / no | yes / yes | yes / yes |
| ray tracing | no | yes | yes |
| MetalFX spatial scaler | yes | yes | yes |
| MetalFX temporal scaler | no | yes | yes |
| cooling | fan | fanless | fanless |
| maximum output | 3840x2160 at 60 Hz | 3840x2160 at 60 Hz | 3840x2160 at 60 Hz |

- Tier on the GPU family or model id, never on memory size (§4).
- Query features at run time (`supportsFamily`, `MTLFXTemporalScalerDescriptor.supportsDevice`); the A12 lacks the temporal scaler, ray tracing and everything else that needs Metal 3.
- No box outputs more than 60 Hz, so the frame budget is always 16.67 ms.

## 2. What fits in a 60 Hz frame

Each figure is the largest load that held 60 Hz for 40 seconds (99th-percentile frame time ≤ 16.67 ms), about one minute into a run on a box that started at its normal thermal state; median of the repeats. In brackets: the same budget after 20 minutes of continuous load (§3). Each test loads one thing alone, so a real frame that mixes them must stay under a blend of these, not under each.

**A12**

| one unit is… | 1080p | 1440p | 2160p |
|---|---|---|---|
| full-screen shader passes | 3 (2) | 2 (1) | nothing fits |
| blended full-screen layers | 75 (58) | 41 (32) | 18 (14) |
| alpha-tested full-screen layers | 96 (81) | 56 (47) | 25 (21) |
| opaque full-screen layers | 1,024 (1,020) | 584 (584) | 260 (260) |
| sprites, one instanced draw | 27,000 (25,400) | 12,000 (11,200) | 6,625 (6,230) |
| sprites, one draw each | 25,500 (23,500) | 11,875 (10,900) | 6,500 (6,000) |
| meshes, one instanced draw | 10,000 (9,560) | 9,500 (9,080) | 7,875 (7,530) |
| meshes, one draw each | 9,800 (9,700) | 9,300 (9,200) | 7,900 (7,820) |

**A15**

| one unit is… | 1080p | 1440p | 2160p |
|---|---|---|---|
| full-screen shader passes | 5 (4) | 3 (2) | 1 (0) |
| blended full-screen layers | 108 (84) | 64 (50) | 29 (22) |
| alpha-tested full-screen layers | 132 (107) | 79 (64) | 37 (30) |
| opaque full-screen layers | 2,240 (2,240) | 1,312 (1,310) | 544 (544) |
| sprites, one instanced draw | 42,000 (32,400) | 22,000 (16,900) | 10,750 (8,290) |
| sprites, one draw each | 36,500 (28,000) | 22,000 (16,800) | 10,750 (8,240) |
| meshes, one instanced draw | 11,875 (11,800) | 11,375 (11,300) | 10,750 (10,700) |
| meshes, one draw each | 12,431 (11,300) | 11,400 (10,400) | 10,600 (9,670) |

**A19**

| one unit is… | 1080p | 1440p | 2160p |
|---|---|---|---|
| full-screen shader passes | 11 (6) | 6 (3) | 2 (1) |
| blended full-screen layers | 150 (95) | 86 (54) | 42 (26) |
| alpha-tested full-screen layers | 168 (111) | 100 (66) | 46 (30) |
| opaque full-screen layers | 3,264 (3,260) | 1,952 (1,950) | 848 (848) |
| sprites, one instanced draw | 55,885 (33,800) | 31,239 (18,900) | 15,392 (9,310) |
| sprites, one draw each | 55,612 (34,700) | 30,890 (19,300) | 15,023 (9,380) |
| meshes, one instanced draw | 21,000 (18,100) | 19,750 (17,000) | 17,750 (15,300) |
| meshes, one draw each | 20,400 (16,900) | 19,200 (15,900) | 17,200 (14,300) |

Units: *full-screen shader passes* = one full-screen pass of a reference fragment shader: 8 bilinear texture samples plus 32 loop iterations of 4-wide arithmetic per pixel, each pass its own render pass; *blended full-screen layers* = one full-screen alpha-blended layer, all in one render pass; *alpha-tested full-screen layers* = one full-screen layer that discards some pixels; *opaque full-screen layers* = one opaque full-screen layer drawn front to back (hidden layers are rejected before shading: a control, it measures almost no pixel work); *sprites, one instanced draw* = one alpha-blended, rotated, textured square, 64x64 px at 1080p (its side scales with the render height); *sprites, one draw each* = the same sprite with its own draw call; *meshes, one instanced draw* = one lit sphere of about 1,000 triangles; *meshes, one draw each* = the same mesh with its own draw call.

- **Plan against the bracketed 20-minute figure** for anything people use for more than a few minutes.
- Per-pixel cost is what runs out first at 2160p. Rendering below 2160p and scaling up is the main lever (§5).
- Compare the instanced and one-draw-each rows. Where they match, the GPU is the limit and instancing only saves CPU time; where one-draw-each is clearly lower (nowhere in these tables), the CPU cost of draw calls is the limit and instancing buys objects.
- The mesh test is limited by triangle throughput (about 10 million triangles a frame on the A12), not by object count: fewer triangles per mesh means proportionally more meshes.

## 3. Heat: budgets shrink while the box still says it is fine

Share of speed kept in minute 20 of a continuous load, against the one-minute mark (1080p, each box at about its own budget load, single runs):

|  | A12 | A15 | A19 |
|---|---|---|---|
| full-screen shader passes | 82 % | 84 % | 62 % |
| blended full-screen layers | 78 % | 78 % | 64 % |
| alpha-tested full-screen layers | 85 % | 82 % | 67 % |
| opaque full-screen layers | 100 % | 104 % | 100 % |
| sprites, one instanced draw | 94 % | 77 % | 61 % |
| sprites, one draw each | 92 % | 77 % | 62 % |
| meshes, one instanced draw | 96 % | 103 % | 86 % |
| meshes, one draw each | 99 % | 91 % | 83 % |

Under the shader-pass load, the A12 never left `nominal`; the A15 read *serious* at 8:36 and never *critical*; the A19 read *serious* at 2:19 and *critical* at 6:44 (minutes:seconds into the run).

How much more fits on a newer chip, by kind of work (1080p; cool = the budgets of §2, warm = after 20 minutes):

|  | A15 ÷ A12 cool | A15 ÷ A12 warm | A19 ÷ A15 cool | A19 ÷ A15 warm |
|---|---|---|---|---|
| full-screen shader passes | 1.7× | 1.7× | 2.2× | 1.6× |
| blended full-screen layers | 1.4× | 1.4× | 1.4× | 1.1× |
| alpha-tested full-screen layers | 1.4× | 1.3× | 1.3× | 1.0× |
| sprites, one instanced draw | 1.6× | 1.3× | 1.3× | 1.0× |
| sprites, one draw each | 1.4× | 1.2× | 1.5× | 1.2× |
| meshes, one instanced draw | 1.2× | 1.2× | 1.8× | 1.5× |
| meshes, one draw each | 1.3× | 1.2× | 1.6× | 1.5× |

- **There is no single "how much faster".** The A19 fits 1.3× to 2.2× what the A15 fits when cool, and 1.0× to 1.6× after 20 minutes, depending on the kind of work. Tier quality by what your frame is made of, not by a chip-wide multiplier.
- **Do not wait for `ProcessInfo.thermalState` to change before shedding load.** tvOS gives four levels, not a temperature. Every chip slows while still reporting `nominal`: the A12 loses about a fifth over 20 minutes and never leaves `nominal`; the A15 is already slower within the first minute. Watch your own frame times and scale quality from them.
- **Pixel shading is what heats the box and what is lost.** Shader passes and blended or alpha-tested overdraw lose the most; geometry-bound work loses little; opaque overdraw (hidden surfaces rejected before shading) loses nothing and does not even raise the thermal state.
- **The newest chip gives up the most.** The A19 is the fastest box and the one that throttles hardest, so the gap between chips after 20 minutes is smaller than a short benchmark shows.
- The A12 model has a fan; the A15 and A19 models are fanless. Where the box sits matters: one of two A19 units reported its highest thermal level while idle in a warm spot.
- A box that has just returned to `nominal` is not yet back to full speed (measured on one A19: 2.7 % slow just after returning, still 0.9 % slow after 240 s more at `nominal`). Benchmarks need a real rest, not a state check.

## 4. Memory: every box gives an app the same limit

- **The per-app limit is about 2,098 MB on all three boxes** (measured: 2,098 / 2,098 / 2,098), although they have 2.9 / 3.9 / 7.9 GiB of RAM. The new box's extra memory is not the app's to use. Do not tier asset quality on `physicalMemory`.
- Metal textures, buffers and render targets count toward it exactly as heap memory does; memory compression does not raise it. It is about 32 uncompressed 4096² RGBA8 textures, or 32 render targets of 3840×2160 rgba16Float, with nothing else loaded.
- `MTLDevice.recommendedMaxWorkingSetSize` (2,048 / 2,731 / 5,461 MB) is above the limit on the newer boxes and cannot be reached.
- `os_proc_available_memory()` is an accurate fuel gauge (exact to the megabyte against the footprint). The first memory warning arrived as early as 1,088 / 1,548 / 1,548 MB held; treat a warning as the last call.
- On the A12 (3 GB) the system can run short of pages before the app reaches its own limit, so leave more margin there.

## 5. Upscaling to 2160p with MetalFX

Shader passes (the unit of §2) that fit at 60 Hz when rendering at a lower size and scaling to 3840×2160:

|  | native 2160p | spatial from 1080p | spatial from 1440p | temporal from 1080p | temporal from 1440p |
|---|---|---|---|---|---|
| A12 | nothing fits | 1 | nothing fits | not supported | not supported |
| A15 | 1 | 2 | 1 | nothing fits | nothing fits |
| A19 | 2 | 8 | 5 | 3 | 1 |

- The scaler has a fixed cost per frame, part of the 16.67 ms whatever else is drawn. Measured inside a real frame from 1080p, scaler plus the frame's other fixed costs: spatial A12 10 ms, A15 8 ms, A19 4 ms; temporal A15 20 ms, A19 11 ms.
- So: spatial upscaling from 1080p is worth it on every chip that is short of 2160p budget; from 1440p it only pays on the A19; use the temporal scaler on the A19 only, and check support at run time.
- Not verified: the temporal scaler's cost with real motion vectors (the test fed it zero motion).

## 6. CPU

|  | A12 | A15 | A19 |
|---|---|---|---|
| CoreMark 1.0, 1 thread, iterations/s | 20,743 | 33,313 | 52,273 |
| Jolt Physics ragdoll scene, 1 thread, steps/s (settled) | 52.0 | 80.7 | 114 |
| Jolt Physics, all threads, steps/s (settled) | 102 | 154 | 223 |
| Jolt all threads, minute 20 ÷ minute 1 | 97 % | 78 % | 67 % |
| memory bandwidth (triad), 1 thread, GB/s | 20.6 | 31.7 | 56.3 |
| zstd level 3 decompress, 1 thread, MB/s | 776 | 1,041 | 1,269 |
| lz4 decompress, 1 thread, MB/s | 2,789 | 4,120 | 5,393 |

- On one thread the A15 is 1.6× the A12 and the A19 2.5× (CoreMark); in the physics scene 1.6× and 2.2×. Plan game logic for the A12's figure and treat the rest as headroom.
- Using every core gave 1.9–2.0× the one-thread physics throughput, not more: every box has only two performance cores. For Box2D-style solvers two workers were fastest on the A12 and A15 in most scenes.
- All-core CPU load throttles too: the A15 and A19 lose a fifth to a third of all-thread speed over 20 minutes; the A12 (fan) loses almost nothing.
- Memory bandwidth does not rise with more threads (it was 5–14 % lower with all threads than with one), so do not parallelise large memory copies expecting a gain.
- CoreMark here was built by the developer under EEMBC's run rules but is not a certified score.

## 7. A reference frame

Apple's deferred-lighting sample (single-pass deferred, 256 point lights, one shadowed sun, 67,000 triangles), settled milliseconds per frame, off-screen:

|  | A12 | A15 | A19 |
|---|---|---|---|
| 1080p | 1.36 ms (735 fps) | 0.88 ms (1,135 fps) | 0.62 ms (1,615 fps) |
| 2160p | 3.24 ms (309 fps) | 2.59 ms (386 fps) | 1.86 ms (537 fps) |

A classic deferred frame with hundreds of small lights is cheap on all three boxes; tile-memory (single-pass) deferred is the right default on these GPUs.

## 8. Testing on real Apple TVs (experience, not measurement)

From automating several hundred launches with `xcrun devicectl` on tvOS 27:

- **A launch command returning is not proof the app is running in front.** Have the app write a heartbeat file (state, a counter, `UIApplication.applicationState`) and read it back with `devicectl device copy from --domain-type appDataContainer`.
- **The screensaver, the profile chooser and system prompts hold an app `inactive` or in the background** and can only be dismissed with the remote. Keep the idle timer disabled while testing, and keep your app running between tests rather than stopping it: a stopped app lets them in.
- **Do not launch right after stopping the app.** A launch a few seconds after a terminate sometimes comes up already in the background and is killed about ten seconds later with no crash report (seen on all three chips). Detect it from the heartbeat and launch again.
- `devicectl device info displays` can report a display as on and active when it is not; trust frames delivered to your app instead.
- Address every box by its identifier, never by name; expect the network link to drop and make every step safe to repeat.
- Measure only Release builds, off-screen and unpaced for throughput, and confirm on screen at 60 Hz separately. Give every result from rest and settled, and never mix a hot box's numbers with a cool one's.
- A memory test that allocates until the system ends the app must journal every step to disk first; the system writes a kill report only some of the time.

## 9. Limits of this pack

- One or two units per chip, one home, tvOS 27.2 and 27.2.1. Other units, placements and ambient temperatures will differ, above all in §3.
- Budgets are for synthetic single-purpose loads; they bound a real frame, they do not predict it.
- 20-minute budgets were measured at 1080p; at other sizes the 1080p share is applied (unverified).
- Not covered: on-screen latency, HDR output cost, audio, storage speed, network, 120 Hz (no box has it).
- If this pack's date is more than a year old or the tvOS major version has changed, re-measure before relying on it.
