Performance Benchmarks

We measured BeatLeader's own UI on Reactive V1 and V2, then ran the same stress tests on V1, V2 and BSML. In BeatLeader, UI time stayed the same while V1's memory leak is gone. In the stress tests, V2 mounts about 4× faster than V1 and lays out faster too, and many writes in one frame cost it far less, though a single write takes a few microseconds longer.

Against BSML, Reactive is much faster when one part of a large UI changes, since only that part is laid out again, and it usually mounts faster because it builds from code. Most rows where BSML comes out ahead are ones where it does less of the work, as the notes under them say.

Each bar shows how many times better one side is, on a log scale. No bar means the difference is within noise. A * marks a row where the two sides don't do the same work or weren't measured the same way, with a note under its group.

BeatLeader

V1 → V2

V1 betterV2 better

Main menu, UI time per frame7.38 → 8.04 mssame

Playing a replay, UI time per frame11.1 → 11.9 mssame

Opening the hub, longest frame108 → 87.9 mssame

Opening the leaderboard, longest frame1385 → 1415 mssame

Memory kept by each replay after the first14.9 → ≤3.0 MB>4.9× less

V1 never frees the Yoga nodes of destroyed Images, Labels and list rows, or anything they reference, so its memory grows for as long as the game runs.

V2 vs V1

V1 → V2

V1 betterV2 better

Layout

No layout engine, parent resizes16.9 → 18.8 ms1.1× slower

1000 flex items, one resizes13.3 → 3.67 ms3.6× faster

500 percent-sized items, root resizes18.4 → 11.5 ms1.6× faster

128 nested containers, innermost resizes19.7 → 2.64 ms7.5× faster

Tree of 1365 growing nodes44.8 → 25.0 ms1.8× faster

300 labels, all change text*42.2 → 35.1 ms1.2× faster

* V1 sets each label's text directly. V2 writes 300 bound states, the way BeatLeader's V2 UI does.

State

One write, one callback2.0 → 7.4 µs3.6× slower

One write, 1000 callbacks74.1 → 38.6 µs1.9× faster

Callbacks writing more states, 6 levels304 → 667 µs2.2× slower

1000 writes per frame, 100 callbacks*730 → 29.3 µs25× faster

1000 subscribes and unsubscribes**5.78 ms → 82.2 µs70× faster

18 stacked diamonds*20.0 ms → 26.7 µs750× faster

* Not the same work: V1 calls back on every write, 100000 times per frame in the burst and 262144 times at the end of the diamonds. V2 runs each callback once per flush, with the latest value.

** V1 has no subscription handle, so this uses its C# event, which copies the whole list of callbacks on every add and remove.

Animation

2000 Images, color33.9 → 31.9 ms1.1× faster

64 flex panels, size and color25.4 → 12.6 ms2.0× faster

Lists

Table of 100000, scrolling8.34 → 8.07 mssame

Flat list of 500 rows, all rebind*275 → 107 ms2.6× faster

Flat list growing by 10 rows per frame*91.7 → 14.4 ms6.4× faster

* V1 ran each of these in a fresh game session, because its leak slows down everything after it, while V2 ran the full suite. So this is V1's best case.

Mounting

1000 Images*320 → 71.8 ms4.5× faster

1000 Labels*865 → 224 ms3.9× faster

500 list rows*1104 → 291 ms3.8× faster

Creating and destroying 50 rows per frame*124 → 31.0 ms4.0× faster

* Also from a fresh V1 session each.

Memory

100000 states18.2 → 24.2 MB1.3× more

5000 animated boxes17.0 → 6.79 MB2.5× less

2000 list rows*82.5 → 73.4 MB1.1× less

* Also from a fresh V1 session.

Single writes, chains of maps and states writing each other are slower because V2 compares the value, queues the state and notifies on flush. That's also what makes bursts cheap, and they all stay under a millisecond.

Both on the same Yoga build

V1 ships with an unoptimized yoga.dll, while V2 was measured on a Release build of it, so the comparison above mixes two things: changes in Reactive and a faster layout engine underneath it. To tell them apart, we swapped V1 onto the same Release build that V2 was measured with and ran the layout and mount benchmarks again. Everything else stayed as before, so any difference left between the two comes from Reactive itself:

V1 → V2

V1 betterV2 better

Layout

1000 flex items, one resizes3.03 → 2.87 mssame

1000 flex items, root resizes3.28 → 5.23 ms1.6× slower

128 nested containers, innermost resizes1.06 → 1.81 mssame

Tree of 1365 growing nodes24.9 → 26.8 mssame

Mounting

1000 Images*312 → 71.8 ms4.3× faster

1000 Labels*764 → 224 ms3.4× faster

500 list rows*1204 → 291 ms4.1× faster

* V1 ran each of these in a fresh game session, V2 in the full suite.

With the engine the same on both sides, V1 catches up on layout and in some cases even runs up to 1.6× faster, so V2's layout lead over the shipped V1 comes from the Release build. Its mounts don't catch up, though, and V2 still mounts 3.4 to 4.3× faster, so that gain is Reactive's own, from the reworked mounting.

Reactive vs BSML

BSML can't always do the same work, see where the work differs.

BSML → V2

BSML betterV2 better

Layout

1000 items, one resizes*12.5 → 3.67 ms3.4× faster

Tree of 1365 nodes, fixed-size leaves34.9 → 5.81 ms6.0× faster

Tree of 1365 growing nodes35.7 → 25.0 ms1.4× faster

300 labels, all change text**20.1 → 35.1 ms1.8× slower

* BSML uses 40 rows of 25, because its layout groups can't wrap items of different sizes. Reactive wraps all 1000 in one container.

** BSML uses 30 rows of 10 and sets each text directly. Reactive wraps all 300 in one container and writes 300 bound states.

State

500 labels showing one value*19.9 → 54.9 ms2.8× slower

* BSML's labels sit in grid cells of a fixed size, so their text isn't measured for layout, while Reactive's are sized by their text.

Animation

2000 Images, color*30.5 → 31.9 mssame

500 items, position only**≈0 → 3.15 ms>1.6× slower

* BSML has no animations, so a hand-written loop works out one value per frame and sets it on every item. Reactive runs a separate animation per item.

** The same loop, and BSML's items ignore layout, so moving them only writes their transforms. Reactive moves absolute flex items, so its layout runs every frame.

Lists

Table of 100000, jumping far*126 → 7.78 ms16× faster

Flat list of 2000 rows, idle15.2 → 21.3 ms1.4× slower

Flat list of 500 rows, all rebind**89.8 → 107 ms1.2× slower

* BSML's custom-list creates and parses a new cell whenever a row comes into view, instead of reusing one. That's BSML's own behavior.

** BSML has no list to give new items to, so each row's bound object is updated in place. Reactive's list gets a new array of items.

Mounting

1000 Images*556 → 71.8 ms7.8× faster

1000 Labels*623 → 224 ms2.8× faster

500 list rows*1444 → 291 ms5.0× faster

Creating and destroying 50 rows per frame*121 → 31.0 ms3.9× faster

* BSML parses its markup on every mount, where Reactive builds from code. BSML also places the first three in a grid of fixed cells rather than wrapping them, so its 1000 Labels aren't measured for layout.

Memory

5000 animated boxes*21.0 → 6.79 MB3.1× less

2000 list rows120 → 73.4 MB1.6× less

* BSML has no animations, so its 5000 Images hold no animation state, while Reactive's hold one each.

How it was measured

Everything was measured on 2026-11-05. UI time is how long the main thread spends on a frame beyond an idle one, taken as the median (p50), while state changes are timed directly. A mount is the median of every mount after the first, counting its first 6 frames, and memory is the managed heap while the benchmark is mounted.

The machine, the versions and the rules are listed below:

UI time window: from the first Update to the end of Canvas.willRenderCanvases.
Same: the ranges over all rounds overlap, or the gap is under 5% or under the noise floor of an empty benchmark, which is 0.66 ms on V1 and V2 and 1.95 ms on BSML.
PC: Beat Saber 1.44.0, Ryzen 7 5800H, RTX 3070 Laptop, in FPFC on a hidden desktop, which makes absolute numbers higher than usual. V1 is Reactive 859fe5d, V2 is Reactive 56b3941 with a Release yoga.dll, BSML is 1.14.1. 3 rounds of V2 and BSML, 2 of V1. BeatLeader ran 2 rounds per version, and its main menu 5 sessions.
Same work: V1 and V2 end with matching layouts, apart from animations, tables and state-subscribe. BSML can't match them, so we compared screenshots of every benchmark instead.
Not covered: PC VR, other machines and GPU cost.

Where the work differs

Each target is written the way its library is normally used: V2 the way BeatLeader's UI is, V1 with its own API, and BSML with markup and ~value bindings. Where that changes the work, or a target was measured differently, the chart row has a * and a note under its group.

Every difference

V1 and V2

Fresh sessions for V1: V1's leak slows down everything after it, so its mounts, flat lists, life-churn and ram-rows each ran in a game session of their own, while V2 ran the full suite. That's V1's best case. V1's mounts on V2's Yoga also come from one session each, and its layout there from 2 rounds.
Callbacks: V1 calls back on every write. That's 100000 calls per frame in state-burst and 262144 at the end of state-diamond-deep, where V2 runs each callback once per flush. So these rows show V2 doing less work by design.
Subscribing: V1 has no subscription handle, so state-subscribe uses its C# event, which copies the whole list of callbacks on every add and remove.
Text: V1 sets label text directly, and V2 writes bound states, so V2's text benchmarks include its state work.

BSML

No wrapping: UGUI's layout groups can't wrap items of different sizes, so where one item changes size, BSML uses rows of a fixed length with the same number of items. Elsewhere a grid of fixed cells stands in for wrapping, so BSML's labels in life-label and state-labels aren't measured for layout, while Reactive's are, and BSML does less work there.
No animations: BSML has no animation system, so a hand-written loop works out one value per frame and sets it on every item, while Reactive runs one animation per item. In anim-position, BSML's items also ignore layout, so only their transforms move, while Reactive's absolute flex items run layout every frame. In ram-animated, BSML's Images hold no animation state. In all three, BSML does less work.
Markup: BSML parses markup on every mount, including all 50 rows per frame in life-churn. That's how BSML builds UI, so it's counted.
Tables: CustomCellListTableData.CellForIdx creates a GameObject and parses the cell again whenever a row comes into view, instead of reusing one. That's BSML's own behavior.
No list component: in list-flat-shuffle, each row's bound object is updated in place, while Reactive's list gets a new array of items.
No state system: state-labels is the only state benchmark with a BSML version, and ram-state is left out.

All numbers

Show all numbers

UI time, p50. Milliseconds per frame over idle. State benchmarks are timed directly.

Benchmark	Case	V1	V2	BSML
`layout-rect` No layout engine: 1000 anchored Images, parent resized every frame	best	16.9	18.8	17.5
`layout-idle` 1000 flex items mounted, nothing changes	best	1.86	1.69	≈0
`layout-panels` 40 fixed-size panels of 25 items: one item changes size inside one panel every frame	best	4.58	2.81	15.1
`layout-leaf` Fixed-size flex: one of 1000 items changes size every frame	average	13.3	3.67	12.5
`layout-root` Fixed-size flex: 1000 items, the root resized every frame	worst	13.4	3.78	3.99
`layout-tree-fixed` The same tree with fixed-size leaves, so nothing is measured, the root resized every frame	worst	20.3	5.81	34.9
`layout-percent` Percent-sized and growing flex: 500 items, the root resized every frame	average	18.4	11.5	13.7
`layout-tree` Tree of nested growing flex containers (1365 nodes), the root resized every frame	worst	44.8	25.0	35.7
`layout-text-one` Text-measured flex: one of 300 labels changes its text every frame	average	3.23	1.47	4.47
`layout-rows` Column of 200 list rows (800 nodes), the root resized every frame	average	29.5	20.0	15.3
`layout-text-all` Text-measured flex: all 300 labels change their text every frame	worst	42.2	35.1	20.1
`layout-tree-text` Tree of content-sized containers with text leaves (364 nodes): text and root change every frame	worst	57.0	19.2	15.4
`layout-deep` 128 nested flex containers, the innermost item changes size every frame	worst	19.7	2.64	5.93
`layout-absolute` 500 absolutely positioned flex items all move every frame	average	5.22	3.46	≈0
`layout-toggle` Half of 200 list rows hide and show every frame	worst	17.7	14.7	19.1
`state-labels` One write per frame updates the text of 500 bound labels through a map	worst	70.6	54.9	19.9
`state-single` One state, one callback, one write per frame	best	2.0 µs	7.4 µs	–
`state-same-value` 1000 writes of the same value per frame, one callback	best	11.9 µs	8.8 µs	–
`state-fanout` One write per frame reaches 1000 callbacks	average	74.1 µs	38.6 µs	–
`state-chain` Callbacks in callbacks: a chain of 100 maps	average	10.7 µs	30.1 µs	–
`state-burst` 1000 writes per frame with 100 callbacks	worst	730 µs	29.3 µs	–
`state-reentrant` Callbacks in callbacks: two states write each other 200 times per frame	worst	17.6 µs	53.2 µs	–
`state-cascade` Callbacks in callbacks: each callback writes four more states, six levels deep (5461 writes)	worst	304 µs	667 µs	–
`state-diamond` Callbacks in callbacks: 14 stacked diamonds, where one write reaches the end by 16384 paths	worst	1.25 ms	22.8 µs	–
`state-diamond-deep` Callbacks in callbacks: 18 stacked diamonds, where one write reaches the end by 262144 paths	worst	20.0 ms	26.7 µs	–
`state-subscribe` 1000 subscribes and unsubscribes per frame on a state with 1000 callbacks	worst	5.78 ms	82.2 µs	–
`anim-color-small` 100 Images animating their color	best	0.69	1.19	≈0
`anim-position` 500 absolute items animating their position	average	5.28	3.15	≈0
`anim-color-large` 2000 Images animating their color, so no layout	average	33.9	31.9	30.5
`anim-size` 200 flex items animating their size, so layout every frame	worst	5.48	4.30	5.19
`anim-retarget` 1000 color animations restarted every frame	worst	17.7	16.3	15.8
`anim-storm` Nested flex dashboard: 64 panels of 4 boxes animating size and color, plus a label changing text every frame	worst	25.4	12.6	13.8
`list-table-idle` Virtualized table with 100000 items, nothing changes	best	0.98	≈0	≈0
`list-table-scroll` Virtualized table with 100000 items, scrolled by a row every frame	average	8.34	8.07	6.63
`list-table-jump` Virtualized table with 100000 items, jumping far every frame so every cell rebinds	worst	7.74	7.78	126
`list-table-refresh` Virtualized table with 10000 items, replaced by a filtered list every frame	worst	9.74	8.44	119
`list-flat-idle` Flat list of 2000 rows (8000 nodes), nothing changes	average	27.3	21.3	15.2
`list-flat-shuffle` Flat list of 500 rows, all shifted by one every frame so every row rebinds	worst	275	107	89.8
`list-flat-grow` Flat list growing by 10 rows every frame	worst	91.7	14.4	37.3
`life-layout-noflex` Mount and destroy 1000 empty Layouts in a parent without a layout controller	best	1.27	≈0	≈0
`life-layout` Mount and destroy 1000 empty Layouts	best	1.79	≈0	≈0
`life-image` Mount and destroy 1000 Images	average	5.08	1.21	≈0
`life-label` Mount and destroy 1000 Labels	average	1.80	1.97	≈0
`life-row` Mount and destroy 500 list rows (background, icon, two labels)	worst	4.33	5.13	2.16
`life-append` Mount and destroy 4000 empty Layouts in one container, to show how appending scales against life-layout	worst	4.56	3.16	6.28
`life-churn` Create and destroy 50 rows every frame	worst	124	31.0	121
`ram-state` 100000 states with one callback each	best	2.28	-1.07	–
`ram-animated` 5000 boxes with a color animation each	average	11.0	9.81	3.55
`ram-rows` 2000 list rows (8000 nodes)	worst	24.2	19.6	11.4

UI time, p99.

Benchmark	V1	V2	BSML
`layout-rect`	29.6	30.0	29.7
`layout-idle`	7.18	6.77	7.20
`layout-panels`	14.8	10.2	29.3
`layout-leaf`	21.4	8.86	36.7
`layout-root`	24.7	11.4	14.1
`layout-tree-fixed`	33.8	13.6	57.7
`layout-percent`	29.4	19.8	26.7
`layout-tree`	63.5	42.7	58.6
`layout-text-one`	10.3	6.60	12.6
`layout-rows`	45.4	33.4	28.4
`layout-text-all`	60.5	54.2	33.5
`layout-tree-text`	85.3	33.4	26.9
`layout-deep`	29.9	7.53	11.6
`layout-absolute`	12.4	10.8	5.77
`layout-toggle`	46.1	33.5	42.7
`state-labels`	101	88.4	34.0
`state-single`	3.9 µs	13.8 µs	–
`state-same-value`	20.0 µs	15.1 µs	–
`state-fanout`	180 µs	71.0 µs	–
`state-chain`	19.0 µs	70.3 µs	–
`state-burst`	1.12 ms	44.3 µs	–
`state-reentrant`	42.9 µs	102 µs	–
`state-cascade`	606 µs	1.21 ms	–
`state-diamond`	1.60 ms	38.0 µs	–
`state-diamond-deep`	25.0 ms	42.7 µs	–
`state-subscribe`	268 ms	134 µs	–
`anim-color-small`	5.27	6.40	6.01
`anim-position`	12.6	10.6	5.36
`anim-color-large`	52.0	52.0	48.0
`anim-size`	13.1	12.0	12.2
`anim-retarget`	28.9	28.5	28.1
`anim-storm`	37.9	24.8	24.8
`list-table-idle`	5.65	4.43	5.19
`list-table-scroll`	16.5	17.9	16.8
`list-table-jump`	15.7	15.9	392
`list-table-refresh`	15.2	17.9	411
`list-flat-idle`	176	34.4	27.1
`list-flat-shuffle`	468	149	143
`list-flat-grow`	213	64.8	74.3
`life-layout-noflex`	3.58	3.25	2.13
`life-layout`	2.94	2.61	2.49
`life-image`	6.81	3.35	4.00
`life-label`	5.19	5.91	3.61
`life-row`	8.62	9.51	6.97
`life-append`	9.97	6.44	11.1
`life-churn`	385	151	299
`ram-state`	3.92	0.66	–
`ram-animated`	12.3	14.8	6.40
`ram-rows`	45.5	28.4	18.3

Mount, ms.

Benchmark	V1	V2	BSML
`layout-rect`	79.5	66.2	582
`layout-idle`	765	70.0	551
`layout-panels`	1453	92.2	765
`layout-leaf`	987	98.7	600
`layout-root`	718	74.2	705
`layout-tree-fixed`	1414	138	745
`layout-percent`	477	43.3	231
`layout-tree`	1158	120	813
`layout-text-one`	530	95.4	170
`layout-rows`	820	130	663
`layout-text-all`	705	83.4	181
`layout-tree-text`	457	62.1	210
`layout-deep`	35.3	14.8	432
`layout-absolute`	1126	36.8	241
`layout-toggle`	1790	115	562
`state-labels`	1303	118	237
`state-single`	11.8	2.06	–
`state-same-value`	3.28	3.72	–
`state-fanout`	3.57	16.7	–
`state-chain`	11.4	1.99	–
`state-burst`	3.36	2.99	–
`state-reentrant`	6.67	4.32	–
`state-cascade`	8.00	5.92	–
`state-diamond`	13.8	5.59	–
`state-diamond-deep`	5.50	10.8	–
`state-subscribe`	7.78	2.10	–
`anim-color-small`	357	15.6	39.1
`anim-position`	681	45.4	316
`anim-color-large`	2882	167	1094
`anim-size`	272	17.6	95.1
`anim-retarget`	1323	88.4	554
`anim-storm`	568	62.3	259
`list-table-idle`	275	35.8	147
`list-table-scroll`	258	30.4	130
`list-table-jump`	206	26.2	120
`list-table-refresh`	229	33.8	110
`list-flat-idle`	4640	1823	6153
`list-flat-shuffle`	952	407	1563
`list-flat-grow`	17.9	0.17	4.39
`life-layout-noflex`	28.7	26.0	527
`life-layout`	40.9	25.8	651
`life-image`	320	71.8	556
`life-label`	865	224	623
`life-row`	1104	291	1444
`life-append`	254	102	2238
`life-churn`	7.93	5.80	9.01
`ram-state`	180	23.5	–
`ram-animated`	27266	441	2672
`ram-rows`	3397	1412	5865

Memory while mounted, MB.

Benchmark	V1	V2	BSML
`layout-rect`	0.82	0.21	3.70
`layout-idle`	1.93	0.48	3.79
`layout-panels`	1.76	0.20	4.07
`layout-leaf`	1.95	0.46	3.79
`layout-root`	1.90	0.41	3.70
`layout-tree-fixed`	2.57	0.54	4.19
`layout-percent`	0.50	≈0	0.72
`layout-tree`	2.72	0.55	4.23
`layout-text-one`	7.29	6.14	8.54
`layout-rows`	8.02	4.95	12.7
`layout-text-all`	7.41	6.06	8.54
`layout-tree-text`	3.38	1.85	4.38
`layout-deep`	≈0	≈0	≈0
`layout-absolute`	0.16	≈0	0.52
`layout-toggle`	7.90	4.97	12.8
`state-labels`	8.01	10.5	10.2
`state-single`	≈0	≈0	–
`state-same-value`	≈0	≈0	–
`state-fanout`	≈0	≈0	–
`state-chain`	≈0	≈0	–
`state-burst`	≈0	≈0	–
`state-reentrant`	≈0	≈0	–
`state-cascade`	≈0	≈0	–
`state-diamond`	≈0	≈0	–
`state-diamond-deep`	≈0	≈0	–
`state-subscribe`	≈0	≈0	–
`anim-color-small`	≈0	≈0	≈0
`anim-position`	0.10	≈0	0.55
`anim-color-large`	5.89	1.45	4.45
`anim-size`	≈0	≈0	≈0
`anim-retarget`	1.87	0.10	3.54
`anim-storm`	0.63	≈0	1.62
`list-table-idle`	1.03	0.55	4.46
`list-table-scroll`	1.17	0.47	4.44
`list-table-jump`	1.13	0.45	4.43
`list-table-refresh`	0.33	0.12	1.45
`list-flat-idle`	125	117	166
`list-flat-shuffle`	27.3	25.1	56.0
`list-flat-grow`	≈0	≈0	≈0
`life-layout-noflex`	0.52	0.43	1.45
`life-layout`	0.70	0.48	6.18
`life-image`	1.99	0.91	4.02
`life-label`	22.0	19.1	21.5
`life-row`	20.6	15.2	27.2
`life-append`	5.59	3.42	11.1
`life-churn`	≈0	≈0	≈0
`ram-state`	18.2	24.2	–
`ram-animated`	17.0	6.79	21.0
`ram-rows`	82.5	73.4	120

Memory left after destroying, MB.

Benchmark	Managed left: V1	BSML	Yoga nodes left: V1
`life-image` Mount and destroy 1000 Images	1.94	0	1001
`life-label` Mount and destroy 1000 Labels	21.9	0.07	1001
`life-row` Mount and destroy 500 list rows (background, icon, two labels)	20.5	0.07	2001
`life-churn` Create and destroy 50 rows every frame	228	0	21401
`list-flat-idle` Flat list of 2000 rows (8000 nodes), nothing changes	125	0	8002
`list-flat-shuffle` Flat list of 500 rows, all shifted by one every frame so every row rebinds	27.9	0	2002
`list-flat-grow` Flat list growing by 10 rows every frame	23.3	0	1682
`ram-rows` 2000 list rows (8000 nodes)	82.3	0	8001

Memory per component.

Component	V1	V2	BSML
Image	1.1 KB	942 B	4.1 KB
Label	20.2 KB	19.4 KB	21.9 KB
Empty container	750 B	557 B	6.3 KB
List row (background, icon, two labels)	35.1 KB	31.1 KB	55.1 KB

Allocated per frame. Benchmarks at 10 KB or more on any target. Only accurate to a heap block.

Benchmark	V1	V2	BSML
`state-subscribe`	24227 KB	0.0 KB	–
`life-churn`	2257 KB	1645 KB	10702 KB
`list-table-refresh`	0.5 KB	0.0 KB	5756 KB
`list-table-jump`	0.8 KB	0.1 KB	4796 KB
`list-flat-grow`	844 KB	606 KB	2936 KB
`list-flat-shuffle`	411 KB	18 KB	16 KB
`list-table-scroll`	3.5 KB	2.5 KB	286 KB
`layout-absolute`	0.7 KB	146 KB	0.1 KB
`state-labels`	47 KB	72 KB	45 KB
`layout-tree-text`	51 KB	24 KB	20 KB
`layout-rows`	28 KB	19 KB	0.3 KB
`layout-rect`	17 KB	2.1 KB	1.9 KB
`layout-text-one`	4.8 KB	4.6 KB	12 KB
`layout-toggle`	11 KB	1.6 KB	0.0 KB

BeatLeader, time.

Where	Metric	V1, ms	V2, ms	Result
Main menu, idle	UI CPU, p50	7.38	8.04	same
Main menu, idle	UI CPU, mean	7.87	8.36	same
Main menu, idle	UI CPU, p99	12.4	14.1	same
Main menu, idle	Whole frame, p50	9.09	9.65	same
Playing a replay	UI CPU, p50	11.1	11.9	same
Playing a replay	UI CPU, mean	11.9	12.4	same
Playing a replay	UI CPU, p99	23.8	20.0	same
Playing a replay	Whole frame, p50	11.7	12.5	same

BeatLeader, opening screens. Longest frame in milliseconds.

Screen	First open: V1	V2	Later opens: V1	V2	Result, first open
Hub	108	87.9	32.6	23.6	same
Settings	41.3	41.6	38.4	25.9	same
Replay manager	515	522	31.5	52.1	same
Leaderboard	1385	1415	107	109	same

BeatLeader, memory.

Where	Metric	V1	V2
Main menu	Managed heap	134 MB	136 MB
Main menu	Unity allocator	1447 MB	1448 MB
Main menu	Process private bytes	3038 MB	3043 MB
Main menu	Live Yoga nodes	432	423
Hub	Managed kept by the first open	0.39 MB	0.17 MB
Settings	Managed kept by the first open	0.45 MB	0.55 MB
Replay manager	Managed kept by the first open	2.15 MB	2.07 MB
Leaderboard	Managed kept by the first open	58.1 MB	70.6 MB
Replay	Managed kept by the first replay	37.3 to 37.8 MB	36.2 to 42.3 MB
Replay	Managed kept by each later replay	14.9 to 15.6 MB	at most 3.0 MB
Replay	Yoga nodes kept by each replay	337	0

V1 on V2's Yoga, layout. Milliseconds per frame.

Benchmark	V1	V1 on V2's Yoga	V2	V1 on V2's Yoga vs V1	V2 vs V1 on V2's Yoga
`layout-leaf`	14.5	3.03	2.87	4.8× faster	same
`layout-root`	14.2	3.28	5.23	4.3× faster	1.6× slower
`layout-percent`	18.1	10.3	14.9	1.8× faster	1.4× slower
`layout-deep`	21.3	1.06	1.81	20× faster	same
`layout-tree-fixed`	23.7	7.18	8.69	3.3× faster	1.2× slower
`layout-tree`	47.0	24.9	26.8	1.9× faster	same
`layout-rows`	35.8	19.4	21.0	1.8× faster	1.1× slower

V1 on V2's Yoga, mounts. Milliseconds.

Benchmark	V1	V1 on V2's Yoga	V2
`life-layout` Mount and destroy 1000 empty Layouts	40.9	43.7	25.8
`life-image` Mount and destroy 1000 Images	320	312	71.8
`life-label` Mount and destroy 1000 Labels	865	764	224
`life-row` Mount and destroy 500 list rows (background, icon, two labels)	1104	1204	291
`life-append` Mount and destroy 4000 empty Layouts in one container, to show how appending scales against life-layout	254	148	102
`ram-rows` 2000 list rows (8000 nodes)	3397	4712	1412

Performance Benchmarks

BeatLeader

V2 vs V1

Both on the same Yoga build

Reactive vs BSML

How it was measured

Where the work differs

All numbers

On this page