---
title: "Sound and shaking"
description: "How a speaker in Professor Oops shakes the paper so salt draws a figure by itself, and how every sound effect is made by code as it happens."
source_name: "Game Tailors"
source_url: "https://professoroops.com/en/inside/sound/"
site_home: "https://professoroops.com/"
source_description: "The drawing app where the paper is real. No ads. No accounts. No personal data: only anonymous counts, which you can switch off."
locale: "en"
legal:
  - "Game Tailors · Schieweg 15Y-40, 2627 AN Delft (NL)"
  - "KvK 92437702 · VAT NL866044474B01"
  - "info@gametailors.com · +31 6 4227 5919"
copyright: "© 2026 Game Tailors"
published_at: "2026-11-10T12:03:58.369Z"
modified_at: "2026-11-10T12:03:58.369Z"
---

# Sound and shaking

## A speaker shakes the paper, and salt draws the figure by itself

Hold the speaker on the paper and the whole sheet starts to shake, in a pattern set by the note and by where you press. Salt hops off the parts that move and settles on the lines that stay still, so a figure appears that nobody drew. Flour does the opposite. And every sound effect you hear is made by code at that moment, from what just happened.

[For engineers](<#hood-engineers>)

![Salt on a shaking sheet gathered into a symmetrical figure around the speaker in the middle, at 519 Hz](<https://professoroops.com/_assets/entity_M3IkbFv4XvDeLsqvXkOp.png>)

## The speaker only shakes the sheet, and its code never mentions salt

Sieve salt over the page, pick up the speaker and hold it in the middle. You hear a steady note. Within seconds the salt runs together into lines and curls, a symmetrical figure like the ones Ernst Chladni made famous with sand on a vibrating plate.

The surprising part is that the speaker's code knows nothing about salt. It does one thing: it sets the sheet shaking, hard in some places and not at all along certain lines. Everything lying on the paper reads that shaking in its own way. A salt grain gets bounced off the parts that move and comes to rest where the sheet is still. No line of code describes the figure. It's what's left once every grain has hopped away from the shaking.

A test holds the code to this. It reads the speaker's source file and fails if it ever mentions grains, foam, soap bubbles, water, ripples or particles. It also reads ten simulation files, among them the grains, the foam, the puddles and the shake map itself, and fails if any of them mentions the speaker. A second test sets the sheet ringing with no speaker on the page at all, and glitter still drifts to the still lines.

The rule each grain follows is written by hand, and it's short: when the sheet under you shakes hard enough, take a step toward where it shakes less. Salt doesn't fly through the air in the game, and it doesn't find the lines by chance. The figure is the only part that nobody wrote.

A speaker shakes the paper, and salt draws the figure by itself

For engineers

### A speaker shakes the paper, and salt draws the figure by itself

The speaker writes one thing: a 64 × 48 shake map, the sum of up to 224 cosine vibration shapes, each weighted by a narrow resonance in log frequency and by how much it moves under the press point. Loose grains are a height field on the paper grid \(512 × 384 at full size\) that steps down the slope of that map if coarse, up it if fine. An automated test reads the speaker's code and fails if it names the grains, glitter, foam or water that lie on the sheet. No sound waves are computed, and the game contains no recorded sound effects.

[Under the hood](<#hood-speaker>)

The speaker only shakes the sheet, and its code never mentions salt

Under the hood

### The speaker only shakes the sheet, and its code never mentions salt

One shake map per page: a 64 × 48 grid of how hard each coarse patch of paper shakes, in the game's own "g". Two sources add up in every patch: a standing figure, which only the speaker writes and which holds until it's replaced, and short local shakes that fade. The speaker's figure also sets how long the ripples on puddles are. When nothing shakes, the map goes to sleep and nothing reads it.

The grain rule, in words, for each cell of loose grains:

1. Wet or frozen grains stay put, and so do grains on a sheet that barely moves.
2. Shaken very hard, some grains are thrown a few cells in a random direction.
3. Shaken moderately, a heap steeper than its angle of repose slides down.
4. Past a bounce threshold, a share of the grains steps one cell along the shake map's slope, downhill for coarse grains, uphill for fine ones, never up a step steeper than the grain can stand.

The share that moves grows with the shaking, up to a cap, and fine powder moves more slowly than coarse grains. Each pass visits part of the cells, in turn, at a lower rate than the frames. Moves are gathered and applied after the pass, so nothing moves twice.

Try it: hold a speaker on salt The game's own ruleThe sheet starts covered in salt, with the speaker already playing in the middle. Drag on the paper to move the speaker, or press Move the speaker; slide the note, or switch to sand or flour. **What to look for:** salt leaves the shaking parts and draws the still lines; flour does the reverse. Turn the volume right down and nothing moves. Turn it right up and grains get thrown about. This is the game's plate formula and grain rule, ported line for line, on a 160 × 120 sheet instead of 512 × 384. Only the checks for wet, frozen and holes are left out, since this sheet has none.

![Salt, sand or flour on a sheet shaken by a speaker; drag to move the speaker](<https://professoroops.com/_assets/entity_SS3Rx9GExvZ1yFbfPLu0.png>)

Note0.768

note—

Volume0.66

On the sheetSaltSandFlour

clarity—

strongest shaking—

grain on still lines—

![Salt on the paper gathered into a symmetrical lacy figure around the speaker held in the centre](<https://professoroops.com/_assets/entity_SdoMnNszOASarVJQx4vL.webp>)

Salt, speaker in the middle, default note. The released game after eight seconds. The salt lies where the sheet stands still.

![Cocoa powder covering the paper except for thin bare lines that follow the same figure, around the speaker held in the centre](<https://professoroops.com/_assets/entity_aaaSIRHptpD57ep2EXi6.webp>)

Cocoa, same note, same spot. The picture turns inside out: fine powder gathers where the sheet shakes and leaves the still lines bare. Flour does the same, but white on white paper it hardly shows.

## Only some notes make a clean figure, and where you press changes it

Slide the note up and the figure doesn't morph smoothly. It snaps in, goes weak and muddled, and then another one snaps in. Real plates do this too. A plate has a set of natural ways to vibrate, each with its own note, and it only answers strongly when you play close to one of them.

The game's sheet has 224 of these shapes. Each is a pattern of stripes across and down the sheet. For a speaker pressed in the middle of the page, 17 places along the slider give a clean figure. Between them the sheet barely answers, and the shaking is a small fraction of a clean figure's.

Where you press matters as much as the note. A shape that is still under the speaker can't be set going from there. Press in the exact middle and only shapes that are symmetric about the middle can answer, which is why centred figures look so tidy. Move the speaker off-centre and other shapes join in, so the figure changes and can lose its symmetry. An automated test checks both.

The figure the slider starts on is a mix. At 519 Hz two shapes, one with six still lines across and two down, the other with four each way, have notes only 3 % apart. Both answer at once, and their sum gives the lacy figure instead of a plain grid. Higher notes broadly give more lines, though not at every step.

[Under the hood](<#hood-notes>)

Only some notes make a clean figure, and where you press changes it

Under the hood

### Only some notes make a clean figure, and where you press changes it

The plate is a closed formula: no solver, no state that changes over time. Each of the 224 shapes is a stripe pattern across times a stripe pattern down, with up to fourteen still lines each way. Its natural note follows a plate's frequency law, so shapes with more lines ring higher, and the sheet's side ratio sets which notes lie close together.

The slider picks a note on a log scale. Each shape answers with a narrow resonance peak around its own note \(a Lorentzian in log frequency\), and its weight is that answer times how much the shape moves under the press point. The figure is the weighted sum, normalised. Only the size of the shaking is kept, so the still lines are where the sum crosses zero.

Clarity, the strongest single answer, is the only thing that scales the strength, so a weak answer keeps its shape but shakes less.

Because every shape splits into a row part and a column part, a recompute is cheap, and it only runs when the note changes or the press point moves noticeably. An automated test checks that two fingers on the page hardly ever trigger one.

The note you hear is a separate scale. The model's range is wider than the ear's; they rise together, but the note is not the frequency the model sheet rings at.

Try it: find the sheet's clean notes The game's own ruleThis is the shake map itself, as the game works it out. White is where the sheet stands still, where salt would gather; red is where it shakes hardest. Drag to move the press point, or press Move the press point, and step from one clean note to the next with the buttons. **What to look for:** press on a white line and the figure weakens or changes. Switch the view to "up and down" to see that neighbouring patches swing in opposite directions, with the still lines running between them. The readout names the strongest shape in the mix by its stripes across and down.

![The shake map of the sheet: white still lines, red where it shakes most; drag to move the press point](<https://professoroops.com/_assets/entity_KbT06hafjPJpM65nwSvW.png>)

Note0.768

note—

ViewHow hard it shakesUp and down

model F—

clarity—

modes in the sum—

strongest: stripes across—

stripes down—

its weight—

![Salt figure on the paper with the speaker held off-centre, near the top left, giving a lopsided pattern](<https://professoroops.com/_assets/entity_5NcILm3qaNBdc2oLdtUb.webp>)

The same note, pressed off-centre. Other shapes join in, so the released game draws a different figure, and it is no longer symmetric about the middle.

Clean figures sit on narrow peaks along the note sliderBetween peaks the sheet answers weakly, and the figure shakes less.

For a speaker in the middle, 17 narrow peaks between 90 and 880 Hz reach a clarity of 0.6 or more; between them the clarity falls far lower. The slider starts on the peak at 519 Hz.

Data table

Clean figures sit on narrow peaks along the note slider

| the note you hear \(Hz\) | speaker in the middle of a 4:3 sheet |
| --- | --- |
| 90 | 0.003 |
| 90.5 | 0.003 |
| 91 | 0.003 |
| 91.6 | 0.003 |
| 92.1 | 0.004 |
| 92.6 | 0.004 |
| 93.1 | 0.004 |
| 93.7 | 0.004 |
| 94.2 | 0.004 |
| 94.7 | 0.004 |
| 95.3 | 0.004 |
| 95.8 | 0.004 |
| 96.4 | 0.005 |
| 96.9 | 0.005 |
| 97.5 | 0.005 |
| 98 | 0.005 |
| 98.6 | 0.005 |
| 99.2 | 0.006 |
| 99.7 | 0.006 |
| 100.3 | 0.006 |
| 100.9 | 0.006 |
| 101.4 | 0.007 |
| 102 | 0.007 |
| 102.6 | 0.007 |
| 103.2 | 0.008 |
| 103.8 | 0.008 |
| 104.4 | 0.009 |
| 105 | 0.009 |
| 105.6 | 0.01 |
| 106.2 | 0.01 |
| 106.8 | 0.011 |
| 107.4 | 0.011 |
| 108 | 0.012 |
| 108.6 | 0.013 |
| 109.2 | 0.014 |
| 109.9 | 0.015 |
| 110.5 | 0.016 |
| 111.1 | 0.017 |
| 111.8 | 0.018 |
| 112.4 | 0.02 |
| 113 | 0.021 |
| 113.7 | 0.023 |
| 114.3 | 0.025 |
| 115 | 0.028 |
| 115.7 | 0.03 |
| 116.3 | 0.033 |
| 117 | 0.037 |
| 117.7 | 0.041 |
| 118.3 | 0.046 |
| 119 | 0.052 |
| 119.7 | 0.059 |
| 120.4 | 0.068 |
| 121.1 | 0.078 |
| 121.7 | 0.092 |
| 122.4 | 0.108 |
| 123.1 | 0.13 |
| 123.8 | 0.158 |
| 124.6 | 0.195 |
| 125.3 | 0.245 |
| 126 | 0.315 |
| 126.7 | 0.412 |
| 127.4 | 0.544 |
| 128.2 | 0.712 |
| 128.9 | 0.887 |
| 129.6 | 0.994 |
| 129.8 | 1 |
| 130.4 | 0.961 |
| 131.1 | 0.811 |
| 131.9 | 0.633 |
| 132.6 | 0.48 |
| 133.4 | 0.364 |
| 134.1 | 0.281 |
| 134.9 | 0.221 |
| 135.7 | 0.177 |
| 136.4 | 0.144 |
| 137.2 | 0.119 |
| 138 | 0.1 |
| 138.8 | 0.085 |
| 139.6 | 0.073 |
| 140.4 | 0.064 |
| 141.2 | 0.056 |
| 142 | 0.049 |
| 142.8 | 0.044 |
| 143.6 | 0.039 |
| 144.4 | 0.035 |
| 145.3 | 0.032 |
| 146.1 | 0.029 |
| 146.9 | 0.026 |
| 147.8 | 0.024 |
| 148.6 | 0.022 |
| 149.5 | 0.021 |
| 150.3 | 0.019 |
| 151.2 | 0.018 |
| 152.1 | 0.016 |
| 152.9 | 0.015 |
| 153.8 | 0.015 |
| 154.7 | 0.016 |
| 155.6 | 0.017 |
| 156.5 | 0.018 |
| 157.3 | 0.02 |
| 158.2 | 0.022 |
| 159.1 | 0.023 |
| 160.1 | 0.026 |
| 161 | 0.028 |
| 161.9 | 0.031 |
| 162.8 | 0.034 |
| 163.7 | 0.038 |
| 164.7 | 0.042 |
| 165.6 | 0.047 |
| 166.6 | 0.053 |
| 167.5 | 0.06 |
| 168.5 | 0.069 |
| 169.4 | 0.08 |
| 170.4 | 0.094 |
| 171.4 | 0.111 |
| 172.4 | 0.134 |
| 173.4 | 0.163 |
| 174.3 | 0.202 |
| 175.3 | 0.256 |
| 176.3 | 0.33 |
| 177.4 | 0.432 |
| 178.4 | 0.571 |
| 179.4 | 0.743 |
| 180.4 | 0.913 |
| 181.4 | 0.999 |
| 181.7 | 0.999 |
| 182.5 | 0.941 |
| 183.5 | 0.781 |
| 184.6 | 0.604 |
| 185.6 | 0.458 |
| 186.7 | 0.348 |
| 187.8 | 0.269 |
| 188.8 | 0.212 |
| 189.9 | 0.17 |
| 191 | 0.139 |
| 192.1 | 0.116 |
| 193.2 | 0.097 |
| 194.3 | 0.083 |
| 195.4 | 0.072 |
| 196.5 | 0.062 |
| 197.6 | 0.055 |
| 198.8 | 0.048 |
| 199.9 | 0.043 |
| 201 | 0.038 |
| 202.2 | 0.035 |
| 203.4 | 0.031 |
| 204.5 | 0.028 |
| 205.7 | 0.026 |
| 206.9 | 0.024 |
| 208 | 0.026 |
| 209.2 | 0.029 |
| 210.4 | 0.032 |
| 211.6 | 0.035 |
| 212.8 | 0.039 |
| 214.1 | 0.044 |
| 215.3 | 0.049 |
| 216.5 | 0.056 |
| 217.8 | 0.064 |
| 219 | 0.073 |
| 220.2 | 0.085 |
| 221.5 | 0.1 |
| 222.8 | 0.119 |
| 224 | 0.144 |
| 225.3 | 0.176 |
| 226.6 | 0.22 |
| 227.9 | 0.28 |
| 229.2 | 0.363 |
| 230.5 | 0.478 |
| 231.8 | 0.631 |
| 233.2 | 0.809 |
| 234.5 | 0.959 |
| 235.6 | 1 |
| 235.8 | 0.995 |
| 237.2 | 0.889 |
| 238.5 | 0.714 |
| 239.9 | 0.546 |
| 241.3 | 0.413 |
| 242.7 | 0.316 |
| 244 | 0.246 |
| 245.4 | 0.195 |
| 246.8 | 0.158 |
| 248.3 | 0.13 |
| 249.7 | 0.108 |
| 251.1 | 0.092 |
| 252.5 | 0.078 |
| 254 | 0.068 |
| 255.4 | 0.059 |
| 256.9 | 0.052 |
| 258.4 | 0.046 |
| 259.8 | 0.041 |
| 261.3 | 0.037 |
| 262.8 | 0.038 |
| 264.3 | 0.042 |
| 265.8 | 0.048 |
| 267.4 | 0.054 |
| 268.9 | 0.061 |
| 270.4 | 0.07 |
| 272 | 0.081 |
| 273.5 | 0.095 |
| 275.1 | 0.113 |
| 276.7 | 0.136 |
| 278.2 | 0.166 |
| 279.8 | 0.206 |
| 281.4 | 0.261 |
| 283 | 0.337 |
| 284.7 | 0.442 |
| 286.3 | 0.584 |
| 287.9 | 0.758 |
| 289.6 | 0.925 |
| 291.2 | 1 |
| 292.9 | 0.93 |
| 294.6 | 0.766 |
| 296.2 | 0.591 |
| 297.9 | 0.447 |
| 299.6 | 0.341 |
| 301.3 | 0.264 |
| 303.1 | 0.208 |
| 304.8 | 0.167 |
| 306.5 | 0.137 |
| 308.3 | 0.114 |
| 310.1 | 0.096 |
| 311.8 | 0.082 |
| 313.6 | 0.071 |
| 315.4 | 0.062 |
| 317.2 | 0.054 |
| 319 | 0.048 |
| 320.8 | 0.043 |
| 322.7 | 0.038 |
| 324.5 | 0.036 |
| 326.4 | 0.04 |
| 328.2 | 0.044 |
| 330.1 | 0.05 |
| 332 | 0.057 |
| 333.9 | 0.065 |
| 335.8 | 0.074 |
| 337.7 | 0.087 |
| 339.7 | 0.102 |
| 341.6 | 0.122 |
| 343.6 | 0.147 |
| 345.5 | 0.181 |
| 347.5 | 0.226 |
| 349.5 | 0.288 |
| 351.5 | 0.375 |
| 353.5 | 0.494 |
| 355.5 | 0.651 |
| 357.6 | 0.83 |
| 359.6 | 0.971 |
| 360.8 | 1 |
| 361.7 | 0.989 |
| 363.7 | 0.871 |
| 365.8 | 0.694 |
| 367.9 | 0.529 |
| 370 | 0.4 |
| 372.1 | 0.307 |
| 374.2 | 0.239 |
| 376.4 | 0.19 |
| 378.5 | 0.154 |
| 380.7 | 0.127 |
| 382.9 | 0.106 |
| 385.1 | 0.117 |
| 387.3 | 0.14 |
| 389.5 | 0.172 |
| 391.7 | 0.214 |
| 393.9 | 0.272 |
| 396.2 | 0.352 |
| 398.5 | 0.463 |
| 400.7 | 0.612 |
| 403 | 0.789 |
| 405.3 | 0.946 |
| 407.2 | 1 |
| 407.6 | 0.998 |
| 410 | 0.907 |
| 412.3 | 0.735 |
| 414.7 | 0.564 |
| 417 | 0.427 |
| 419.4 | 0.326 |
| 421.8 | 0.253 |
| 424.2 | 0.244 |
| 426.7 | 0.313 |
| 429.1 | 0.409 |
| 431.6 | 0.54 |
| 434 | 0.707 |
| 436.5 | 0.883 |
| 439 | 0.993 |
| 440 | 0.999 |
| 441.5 | 0.964 |
| 444 | 0.817 |
| 446.6 | 0.638 |
| 449.1 | 0.484 |
| 451.7 | 0.368 |
| 454.3 | 0.344 |
| 456.9 | 0.452 |
| 459.5 | 0.597 |
| 462.1 | 0.773 |
| 464.7 | 0.936 |
| 467.4 | 1 |
| 470.1 | 0.919 |
| 472.8 | 0.751 |
| 475.5 | 0.577 |
| 478.2 | 0.437 |
| 480.9 | 0.333 |
| 483.7 | 0.258 |
| 486.4 | 0.204 |
| 489.2 | 0.165 |
| 492 | 0.135 |
| 494.8 | 0.155 |
| 497.6 | 0.191 |
| 500.5 | 0.24 |
| 503.4 | 0.308 |
| 506.2 | 0.401 |
| 509.1 | 0.53 |
| 512 | 0.695 |
| 515 | 0.872 |
| 517.9 | 0.989 |
| 519.1 | 1 |
| 520.9 | 0.97 |
| 523.8 | 0.853 |
| 526.8 | 0.982 |
| 528 | 0.999 |
| 529.9 | 0.98 |
| 532.9 | 0.848 |
| 535.9 | 0.669 |
| 539 | 0.509 |
| 542.1 | 0.386 |
| 545.2 | 0.296 |
| 548.3 | 0.232 |
| 551.4 | 0.185 |
| 554.6 | 0.15 |
| 557.7 | 0.124 |
| 560.9 | 0.104 |
| 564.1 | 0.088 |
| 567.4 | 0.076 |
| 570.6 | 0.066 |
| 573.9 | 0.057 |
| 577.1 | 0.051 |
| 580.4 | 0.045 |
| 583.8 | 0.04 |
| 587.1 | 0.036 |
| 590.5 | 0.039 |
| 593.8 | 0.044 |
| 597.2 | 0.049 |
| 600.6 | 0.055 |
| 604.1 | 0.063 |
| 607.5 | 0.073 |
| 611 | 0.085 |
| 614.5 | 0.099 |
| 618 | 0.118 |
| 621.5 | 0.143 |
| 625.1 | 0.175 |
| 628.7 | 0.218 |
| 632.3 | 0.278 |
| 635.9 | 0.36 |
| 639.5 | 0.474 |
| 643.2 | 0.626 |
| 646.8 | 0.804 |
| 650.5 | 0.956 |
| 653.5 | 1 |
| 654.3 | 0.996 |
| 655.8 | 1 |
| 658 | 0.979 |
| 661.8 | 0.847 |
| 665.5 | 0.668 |
| 669.4 | 0.768 |
| 673.2 | 0.932 |
| 677 | 1 |
| 680.9 | 0.923 |
| 684.8 | 0.756 |
| 688.7 | 0.843 |
| 692.6 | 0.978 |
| 695 | 1 |
| 696.6 | 0.984 |
| 700.6 | 0.858 |
| 704.6 | 0.679 |
| 708.6 | 0.517 |
| 712.7 | 0.392 |
| 716.7 | 0.301 |
| 720.8 | 0.291 |
| 725 | 0.379 |
| 729.1 | 0.499 |
| 733.3 | 0.657 |
| 737.5 | 0.836 |
| 741.7 | 0.974 |
| 744.2 | 1 |
| 745.9 | 0.987 |
| 750.2 | 0.865 |
| 754.5 | 0.687 |
| 758.8 | 0.523 |
| 763.1 | 0.396 |
| 767.5 | 0.304 |
| 771.9 | 0.237 |
| 776.3 | 0.191 |
| 780.7 | 0.24 |
| 785.2 | 0.308 |
| 789.7 | 0.402 |
| 794.2 | 0.53 |
| 798.7 | 0.695 |
| 803.3 | 0.872 |
| 807.9 | 0.99 |
| 809.7 | 1 |
| 812.5 | 0.97 |
| 817.1 | 0.828 |
| 821.8 | 0.649 |
| 826.5 | 0.493 |
| 831.2 | 0.525 |
| 836 | 0.69 |
| 840.8 | 0.867 |
| 845.6 | 0.988 |
| 847.5 | 1 |
| 850.4 | 0.973 |
| 855.3 | 0.834 |
| 860.2 | 0.655 |
| 865.1 | 0.522 |
| 870 | 0.685 |
| 875 | 0.863 |
| 880 | 0.986 |

Source: Computed on this page with the game's own plate formula, 401 slider positions plus the 17 clean-figure peaks.

## Sand and fine powder go opposite ways, as they do on a real plate

Sieve cocoa instead of salt and the picture turns inside out. The cocoa gathers where the sheet shakes hardest and leaves the still lines bare. Flour does the same, but white on white paper it hardly shows. Real powders do this. Félix Savart noticed it, and Michael Faraday explained it in 1831: very fine powder is swept along by the air the vibrating plate stirs up, while heavier grains bounce until they land where the plate is still.

The game doesn't compute that air. It sorts each material by grain size. Coarse grains \(sand, salt, yeast, chia seeds\) step down the shake map. Fine powders \(flour, cocoa, icing sugar, baking soda, cornflour\) step up it, more slowly. That's a written rule, and it's in the table at the bottom of this page. What isn't written anywhere is the figure each one draws.

The volume knob sets how thin the lines are. A grain only bounces where the sheet shakes harder than a set threshold, so the quiet strip along each still line is where grains come to rest. Turn it up and that strip narrows. But shake too hard and the grains on the most shaken parts are thrown a few cells in any direction, and the figure turns messy. Too quiet, and nothing lifts at all.

Sand piles its lines only as steep as sand can stand. Bouncing heaps grains up, the slope rule slides them down, and an automated test checks that after ten seconds almost no cell is steeper than sand can hold. Wet the sand first and it stays where it is.

[Under the hood](<#hood-powders>)

Sand and fine powder go opposite ways, as they do on a real plate

Under the hood

### Sand and fine powder go opposite ways, as they do on a real plate

Every material carries a grain size and its own angle of repose. Ten of them are loose grains: five coarse \(sand, salt, yeast, chia and flax seeds\) and five fine \(flour, cocoa, icing sugar, baking soda, cornflour\).

Why lines form: the size of the shaking has a V-shaped valley along each still line, so the shake map slopes into the line from both sides. Coarse grains go downhill and stop once the shaking under them drops below the bounce threshold. Louder playing pushes that point closer to the line, so the lines get thinner. With no slope at all, a coarse grain hops in a random direction and a fine one stays.

The direction comes from the slope, and each grain steps across and down at random in proportion to it, so a diagonal slope gives diagonal steps on a square grid. Everything a grain carries, such as its colour, travels with it.

Salt goes to the still lines, flour leaves them"Still line": shaking below 25 % of the peak. A direction, not an accuracy: there is no real-world reference value.

Before the speaker 42 % of the grains lie on still lines; after 8 s salt has 90 % there and sand 68 %, while baking soda has 22 % and flour 20 %.

Data table

Salt goes to the still lines, flour leaves them

|  | after 8 s |
| --- | --- |
| at first | 42 |
| salt | 90 |
| sand | 68 |
| baking soda | 22 |
| flour | 20 |

Source: The game itself, speaker held 8 s, recorded in the project's fact sheet.

Louder narrows the lines, until grains flyGrains rest where the line dips below the bounce threshold.

Along the middle row at the starting note, the shaking dips to zero at each still line; at the default volume it peaks at 1.32 "g", at full volume at 2, past the 1.5 at which grains fly wild.

- volume 0.66 \(default\)
- full volume

Data table

Louder narrows the lines, until grains fly

| across the middle of the sheet \(0 left, 1 right\) | volume 0.66 \(default\) | full volume |
| --- | --- | --- |
| 0 | 0.363 | 0.55 |
| 0.0063 | 0.359 | 0.543 |
| 0.0125 | 0.346 | 0.524 |
| 0.0187 | 0.325 | 0.492 |
| 0.025 | 0.296 | 0.449 |
| 0.0313 | 0.26 | 0.394 |
| 0.0375 | 0.217 | 0.329 |
| 0.0437 | 0.168 | 0.255 |
| 0.05 | 0.114 | 0.172 |
| 0.0563 | 0.055 | 0.083 |
| 0.0625 | 0.007 | 0.011 |
| 0.0688 | 0.072 | 0.109 |
| 0.075 | 0.138 | 0.208 |
| 0.0813 | 0.204 | 0.308 |
| 0.0875 | 0.269 | 0.407 |
| 0.0938 | 0.331 | 0.502 |
| 0.1 | 0.391 | 0.592 |
| 0.1062 | 0.446 | 0.676 |
| 0.1125 | 0.496 | 0.752 |
| 0.1187 | 0.54 | 0.818 |
| 0.125 | 0.577 | 0.874 |
| 0.1313 | 0.606 | 0.918 |
| 0.1375 | 0.626 | 0.948 |
| 0.1437 | 0.637 | 0.965 |
| 0.15 | 0.638 | 0.967 |
| 0.1563 | 0.63 | 0.955 |
| 0.1625 | 0.612 | 0.928 |
| 0.1688 | 0.584 | 0.885 |
| 0.175 | 0.546 | 0.828 |
| 0.1812 | 0.499 | 0.756 |
| 0.1875 | 0.443 | 0.671 |
| 0.1938 | 0.378 | 0.572 |
| 0.2 | 0.305 | 0.462 |
| 0.2062 | 0.226 | 0.342 |
| 0.2125 | 0.14 | 0.212 |
| 0.2188 | 0.049 | 0.075 |
| 0.225 | 0.045 | 0.068 |
| 0.2313 | 0.142 | 0.215 |
| 0.2375 | 0.241 | 0.365 |
| 0.2437 | 0.339 | 0.514 |
| 0.25 | 0.437 | 0.662 |
| 0.2562 | 0.532 | 0.806 |
| 0.2625 | 0.623 | 0.943 |
| 0.2687 | 0.709 | 1.074 |
| 0.275 | 0.788 | 1.194 |
| 0.2813 | 0.86 | 1.303 |
| 0.2875 | 0.923 | 1.399 |
| 0.2938 | 0.977 | 1.48 |
| 0.3 | 1.02 | 1.545 |
| 0.3063 | 1.051 | 1.592 |
| 0.3125 | 1.071 | 1.622 |
| 0.3187 | 1.078 | 1.633 |
| 0.325 | 1.072 | 1.624 |
| 0.3312 | 1.053 | 1.595 |
| 0.3375 | 1.021 | 1.547 |
| 0.3438 | 0.976 | 1.479 |
| 0.35 | 0.919 | 1.392 |
| 0.3563 | 0.849 | 1.287 |
| 0.3625 | 0.769 | 1.165 |
| 0.3688 | 0.677 | 1.026 |
| 0.375 | 0.576 | 0.873 |
| 0.3812 | 0.467 | 0.707 |
| 0.3875 | 0.35 | 0.53 |
| 0.3937 | 0.227 | 0.345 |
| 0.4 | 0.1 | 0.152 |
| 0.4063 | 0.03 | 0.046 |
| 0.4125 | 0.162 | 0.245 |
| 0.4188 | 0.294 | 0.445 |
| 0.425 | 0.423 | 0.642 |
| 0.4313 | 0.55 | 0.833 |
| 0.4375 | 0.672 | 1.018 |
| 0.4437 | 0.787 | 1.193 |
| 0.45 | 0.895 | 1.356 |
| 0.4562 | 0.993 | 1.505 |
| 0.4625 | 1.081 | 1.638 |
| 0.4688 | 1.157 | 1.753 |
| 0.475 | 1.221 | 1.85 |
| 0.4813 | 1.272 | 1.927 |
| 0.4875 | 1.308 | 1.982 |
| 0.4938 | 1.33 | 2.016 |
| 0.5 | 1.338 | 2.027 |
| 0.5062 | 1.33 | 2.016 |
| 0.5125 | 1.308 | 1.982 |
| 0.5188 | 1.272 | 1.927 |
| 0.525 | 1.221 | 1.85 |
| 0.5313 | 1.157 | 1.753 |
| 0.5375 | 1.081 | 1.638 |
| 0.5437 | 0.993 | 1.505 |
| 0.55 | 0.895 | 1.356 |
| 0.5563 | 0.787 | 1.193 |
| 0.5625 | 0.672 | 1.018 |
| 0.5687 | 0.55 | 0.833 |
| 0.575 | 0.423 | 0.642 |
| 0.5813 | 0.294 | 0.445 |
| 0.5875 | 0.162 | 0.245 |
| 0.5938 | 0.03 | 0.046 |
| 0.6 | 0.1 | 0.152 |
| 0.6062 | 0.227 | 0.345 |
| 0.6125 | 0.35 | 0.53 |
| 0.6188 | 0.467 | 0.707 |
| 0.625 | 0.576 | 0.873 |
| 0.6312 | 0.677 | 1.026 |
| 0.6375 | 0.769 | 1.165 |
| 0.6438 | 0.849 | 1.287 |
| 0.65 | 0.919 | 1.392 |
| 0.6563 | 0.976 | 1.479 |
| 0.6625 | 1.021 | 1.547 |
| 0.6687 | 1.053 | 1.595 |
| 0.675 | 1.072 | 1.624 |
| 0.6813 | 1.078 | 1.633 |
| 0.6875 | 1.071 | 1.622 |
| 0.6937 | 1.051 | 1.592 |
| 0.7 | 1.02 | 1.545 |
| 0.7063 | 0.977 | 1.48 |
| 0.7125 | 0.923 | 1.399 |
| 0.7188 | 0.86 | 1.303 |
| 0.725 | 0.788 | 1.194 |
| 0.7312 | 0.709 | 1.074 |
| 0.7375 | 0.623 | 0.943 |
| 0.7438 | 0.532 | 0.806 |
| 0.75 | 0.437 | 0.662 |
| 0.7562 | 0.339 | 0.514 |
| 0.7625 | 0.241 | 0.365 |
| 0.7688 | 0.142 | 0.215 |
| 0.775 | 0.045 | 0.068 |
| 0.7813 | 0.049 | 0.075 |
| 0.7875 | 0.14 | 0.212 |
| 0.7937 | 0.226 | 0.342 |
| 0.8 | 0.305 | 0.462 |
| 0.8063 | 0.378 | 0.572 |
| 0.8125 | 0.443 | 0.671 |
| 0.8187 | 0.499 | 0.756 |
| 0.825 | 0.546 | 0.828 |
| 0.8313 | 0.584 | 0.885 |
| 0.8375 | 0.612 | 0.928 |
| 0.8438 | 0.63 | 0.955 |
| 0.85 | 0.638 | 0.967 |
| 0.8562 | 0.637 | 0.965 |
| 0.8625 | 0.626 | 0.948 |
| 0.8688 | 0.606 | 0.918 |
| 0.875 | 0.577 | 0.874 |
| 0.8812 | 0.54 | 0.818 |
| 0.8875 | 0.496 | 0.752 |
| 0.8938 | 0.446 | 0.676 |
| 0.9 | 0.391 | 0.592 |
| 0.9063 | 0.331 | 0.502 |
| 0.9125 | 0.269 | 0.407 |
| 0.9187 | 0.204 | 0.308 |
| 0.925 | 0.138 | 0.208 |
| 0.9313 | 0.072 | 0.109 |
| 0.9375 | 0.007 | 0.011 |
| 0.9437 | 0.055 | 0.083 |
| 0.95 | 0.114 | 0.172 |
| 0.9563 | 0.168 | 0.255 |
| 0.9625 | 0.217 | 0.329 |
| 0.9688 | 0.26 | 0.394 |
| 0.975 | 0.296 | 0.449 |
| 0.9812 | 0.325 | 0.492 |
| 0.9875 | 0.346 | 0.524 |
| 0.9938 | 0.359 | 0.543 |
| 1 | 0.363 | 0.55 |

Source: The game's own shake map at the starting note \(519 Hz\), speaker in the middle, sampled along the middle row with the game's plate formula; thresholds from the game's grain rule.

## A hammer blow or a passing toy car shakes the paper too, and sand, bubbles and ants feel it

The speaker isn't the only thing that shakes the paper. A hammer blow, a water drop landing, a toy car driving past, the table being bumped and the monster truck rumbling by all write to the same shake map. They make a local shake that fades with distance and has no figure in it. Only the speaker can set the whole sheet ringing in a pattern.

Everything lying on the sheet reads that one map, each thing at its own threshold. Marbles are shaken loose by almost anything. Glitter and confetti need a little more, the same as it takes to bounce a grain of salt. Puddles ripple, the bubbles on soapy suds pop, sand turns runny. Shaving foam is a stiff bed with no bubbles, and the shaking leaves it as it is. The shake ladder below puts them all on one scale, with what each thing that shakes the sheet sets off.

Creatures feel it too. Ants and snails can't hear anything in the game, but they feel the sheet. Hold the speaker near a line of ants and they scatter. Bump the table and a pigeon takes off, a snail tucks into its shell, ants scatter and sand jumps, all from one shake. Automated tests check each of these. Animals react to change, so a fan that keeps blowing startles a pigeon at most once.

[Under the hood](<#hood-sheet>)

A hammer blow or a passing toy car shakes the paper too, and sand, bubbles and ants feel it

Under the hood

### A hammer blow or a passing toy car shakes the paper too, and sand, bubbles and ants feel it

A local shake has a place, a reach and a strength. It is strongest at the centre and fades to nothing at the edge of its reach. Repeated shakes in one place are peak-held, so they don't add up, and each one dies away within a fraction of a second. Any blow shakes the sheet in proportion to the root of its energy.

Things with friction or glue share one loosening rule: nothing until the shaking beats their grip, then a rattle plus a push toward the still lines.

Creatures read the sheet through a coarser layer of what they feel, which also fades. Each species has its own sensitivity: ants and snails feel the most, dogs the least.

Cost: the shake map is 3,072 values against 196,608 paper cells, it sleeps when still, and passes only visit the rows a shake can reach. A test pins it under 4 ms a tick for a full-size sheet covered in sand. This is plain JavaScript; no WebAssembly kernel reads the shake map.

The game's own rule The game's own constants. The scale is the game's own "g", tuned for play, not real acceleration. The speaker at its default volume reaches everything up to runny sand without throwing grains about; turn it up past 0.75 and it reaches the wild rung too.

The shake ladder

| From | What happens | What |
| --- | --- | --- |
| 0.03 "g" | A heap steeper than its grains can stand slides down | heaps |
| 0.04 "g" | Marbles and balls are shaken loose \(toy cars from 0.05\) | rolling things |
| 0.12 "g" | Dry grains bounce; glitter and confetti are shaken loose | grains, bits |
| 0.2 "g" | Puddles show ripples | puddles |
| 0.4 "g" | Bubbles on soapy foam and resting soap bubbles start to pop | bubbles |
| 0.6 "g" | Sand turns runny: no slope holds it | sand |
| 1.5 "g" | Grains are thrown about; puddles throw spray | grains, puddles |

What each shaker reaches

| Shaker | Shakes the sheet | Highest rung it reaches |
| --- | --- | --- |
| Speaker, volume 0.66 | 1.32 "g" on a clean figure, at its strongest spot | 0.6 "g": Sand turns runny: no slope holds it |
| Speaker, full volume | 2.00 "g" on a clean figure, at its strongest spot | 1.5 "g": Grains are thrown about; puddles throw spray |
| Water drop | 0.50 "g" where it lands, fading over 14 cells | 0.4 "g": Bubbles on soapy foam and resting soap bubbles start to pop |
| Toy car | 0.70 "g" at full speed, under it | 0.6 "g": Sand turns runny: no slope holds it |
| Hammer | 1.20 "g" at the blow, fading with distance | 0.6 "g": Sand turns runny: no slope holds it |
| Table bumped | 1.50 "g" everywhere at once, for 0.9 s | 1.5 "g": Grains are thrown about; puddles throw spray |
| Monster truck | 2.50 "g" beside it, fading over 400 cells | 1.5 "g": Grains are thrown about; puddles throw spray |

### Shakes the sheet

- **Speaker:** a whole-sheet figure
- **Hammer and any blow:** strong, local
- **Table bumped:** everywhere at once, briefly
- **Monster truck:** the strongest, fading over a long way
- **Toy car driving, water drops, hole punch:** light, local

### Shared

- **The shake map:** how hard each spot of paper shakes
- **The feel layer:** what creatures feel

### Reads it

- **Sand, salt, seeds:** to the still lines
- **Flour, cocoa, baking soda:** to the shaking parts
- **Puddles:** ripples; spray when shaken hard
- **Bubbles on soapy foam, and resting soap bubbles:** pop when shaken hard enough
- **Glitter, confetti, stickers, marbles, toy cars:** shaken loose past their grip
- **Ants, snails, flies, pigeons, cats, dogs:** startle at a sudden change

No arrow runs from a shaker straight to a reader. An automated test enforces it for the speaker in both directions, and another checks the table bump's own code, which may not name cups, balls, bits, sticks or cars. One exception remains in the shaking: a blow also kicks googly eyes directly, besides shaking the sheet.

![Rows of soapy suds with the speaker in the middle: the bubbles on top have popped round the speaker and in patches either side, and survive in clusters between and above and below](<https://professoroops.com/_assets/entity_FBmxPXH2V6RP7yLQU13R.webp>)

Speaker on soapy suds. Bubbles pop where the sheet shakes hard enough. They are gone round the speaker and either side, and survive in the quieter places where salt gathered in the figure above. A test pins this.

![A line of ants on the paper breaking up and scattering away from the speaker](<https://professoroops.com/_assets/entity_JR2zi7WGd4fMkVgYvvMM.webp>)

Speaker near a line of ants. Ants are deaf in the game, so they flee because they feel the sheet move, at full sensitivity. A test pins this.

## Every sound effect is made by code at the moment it happens

There isn't a single recorded sound effect in the game. A splat is a burst of filtered noise with a falling tone under it. A bonk is a tone gliding down with a short click on top. Fire is noise through a filter, and it gets louder as more of the page burns. The flies' buzz wobbles and grows a little with every fly, up to a quiet ceiling, so a swarm hums instead of roaring. The toy car's motor rises in pitch with its speed. The only audio files are the six songs and the professor's spoken lines.

A sound is also something that happens in the world. When the game plays a bang at a place, the bang writes a patch of noise that creatures hear, as loud as that kind of sound is: a splash is loud, a clink much quieter, a pencil scribble hardly there. The game does this before it checks whether you've muted it, so with the sound off a cat nearby still hears the bang. A dog doesn't startle at its own bark, because each creature takes the noise it made itself off what it hears. The pigeon nearby does startle, by its own hearing, and no code tells it the dog barked. An automated test checks it.

The professor's mouth opens and shuts with the loudness of his voice as it plays. That's two pictures, mouth shut and mouth open, swapped on loudness and each held a moment so they don't flicker. It isn't lip-sync. While he talks, the music dips.

[Under the hood](<#hood-sounds>)

Every sound effect is made by code at the moment it happens

Under the hood

### Every sound effect is made by code at the moment it happens

Everything is synthesised on Web Audio. Nearly every one-shot is built from two primitives:

- A noise burst: a stretch of shared noise, started at a random point and played at a slightly random speed so no two sound alike, through one filter that can glide, with a fast attack and an exponential fade.
- A tone: one oscillator with an optional pitch glide and the same kind of fade.

50 named one-shots, each rate-limited so dragging doesn't machine-gun them, and 7 loops driven by a level from the simulation: fire, fly buzz, blower, car motor, speaker hum, electric zap, cat purr. Pausing the audio silences every loop at once without restarting any.

The simulation runs in a Web Worker, which has no audio. There a silent stand-in takes every sound call, so creatures still hear it, and notes it down; the list travels with each frame and the main thread plays it.

A sound with a place writes noise that creatures hear. Its loudness depends on the kind of sound and its size, up to a cap; louder sounds reach farther, and the noise dies away within a fraction of a second. The mouth follows the loudness of the voice as it plays.

Try it: four loops, driven by the game The game's own ruleThe game's own recipe. Each sound is rebuilt here from the game's recipe, with the same oscillators, filters and numbers, and drawn as its waveform: a whole second and a half on top, a 30-millisecond close-up underneath. Pick a sound and move the slider to the quantity the game feeds it. Tap the waveform to hear three seconds. **What to look for:** fire is all noise and thickens with the burning; the car and the speaker are regular waves whose spacing shrinks as the pitch rises.

![Waveform of a game sound loop, rebuilt from the game's recipe](<https://professoroops.com/_assets/entity_WWN7CRDyQWkLSt7qRXQY.png>)

- 0 s
- 1.5 s
- close-up: 30 ms
- ▼ close-up
- Working it out…
- This browser can't render audio here.

SoundFireFliesToy carSpeaker

Fed by0.4

fed by—

of—

recipe—

gain—

pitch—

crackle ticks—

drawn at—

sound—

How loud each sound is to the creatures on the tableA played sound with a place writes noise that creatures hear, louder and wider for bigger sounds.

A splash is the loudest at 1.2; a bonk and a bark are 1, a flap 0.8, a clink 0.5, a pop 0.4, a rattle 0.2 and a scribble 0.05.

Data table

How loud each sound is to the creatures on the table

|  | loudness |
| --- | --- |
| splash | 1.20 |
| bonk | 1.00 |
| bark | 1.00 |
| flap | 0.80 |
| clink | 0.50 |
| pop | 0.40 |
| rattle | 0.20 |
| scribble | 0.05 |

Source: The game's own loudness table. Tuned for play, not measured.

### Heavier things knock lower, and a higher drop knocks louder

In the released game, a falling apple plays the same knock whatever height it falls from. In the next update, what you hear when something lands is worked out from the landing itself. How loud goes by the square root of its energy, so the same apple dropped from higher is louder. The pitch goes by the cube root of its weight, so a tin of paint thuds low and a strawberry ticks high. And a soft landing is duller: drop the apple into a deep blob of paint and it's quieter and lower. Automated tests check all three.

Try it: drop something on the paper The game's own rulenext update Pick a thing, set how high it falls from and how much runny paint it lands in. The game's formula picks how loud and at what pitch, and the game's voice recipe for that thing plays it: tap the waveform to hear it. **What to look for:** the apple from higher is taller in the waveform \(every knock is drawn at one fixed scale\) but its tone doesn't change; paint underneath makes it shorter and lower. \(In the game a deep cushion can also swap the voice for a pat or a splat; this demo keeps each thing's own voice.\)

![Waveform of the knock a falling thing makes, worked out from its weight, height and landing](<https://professoroops.com/_assets/entity_L0oprTAHKwSlwMbGu8TG.png>)

- 0 s
- 0.5 s
- close-up: 60 ms
- ▼ close-up
- Working it out…
- This browser can't render audio here.

DropStrawberryChocolateAppleMudTin of paint

From70 cells

Paint under it0.0 cells

lands at—

voice—

loud—

size—

pitch—

sound—

[Under the hood: the knock formula](<#hood-knock>)

The knock formula

Under the hood

### The knock formula

next update The landing's energy comes from the thing's mass and the speed it lands at, E = ½·m·v², and a hammer blow is the reference everything else is measured against. How hard the landing is depends on the thing's own face and on how deep the soft stuff under it is.

Loudness grows with the square root of the energy, up to a cap, and a soft landing takes some of it off. Pitch goes with the cube root of one over the mass, kept within a range, and a soft landing lowers it a little. Every frequency in the thing's voice is scaled by that pitch, and very quiet knocks lose their click too.

The cube root is reasoned, not fitted: for the same shape, ring frequency goes as 1/size, and size as mass<sup>⅓</sup>. A few of the smallest things share the top of the range.

## The salt figures come from 224 shake patterns, and not one sound in the game is a recording

224

Vibration shapes the sheet can mix, with up to fourteen still lines each way.

17

Places on the note slider where a speaker in the middle of a 4:3 page gives a clean figure, calculated from the game's plate formula.

1/64

The shake map's size against the paper's: 3,072 values steer 196,608 cells.

10

Grains and powders that read the shake map, five coarse and five fine, sorted by one rule with its sign flipped.

0

Recorded sound effects. 50 one-shots and 7 loops are built by code as they play.

4 ms

Budget for one tick of a full-size sheet covered in sand under the speaker, pinned by a test.

### Connected to the rest of the page

Shared: shake map → what creatures feel

#### Hold the speaker near a line of ants

They scatter. Ants are deaf in the game; they feel the sheet. Pinned by a test.

*[Animals with their own minds](<https://professoroops.com/en/inside/creatures/>)*

Shared: shake map \+ a jolt

#### Bump the table

A pigeon takes off, a snail tucks in, ants scatter and sand jumps, from one shake. Pinned by tests.

*[Animals with their own minds](<https://professoroops.com/en/inside/creatures/>)*

Shared: shake map, hard enough

#### Hold the speaker on soapy suds

Bubbles pop where it shakes and survive where it is still. Pinned by a test.

*[Runny, sticky and oily](<https://professoroops.com/en/inside/liquids/>)*

Shared: wetness

#### Wet the sand, then play the speaker

The sand stays where it is: wet grains stick together. Pinned by a test.

*[Water in paper](<https://professoroops.com/en/inside/water/>)*

Shared: a local shake

#### Hammer beside a heap of sand

The heap slumps to its own angle. Pinned by a test.

*[Things that push things](<https://professoroops.com/en/inside/pushing/>)*

Shared: sound → noise creatures hear

#### Mute the game, then make a bang

The pet still hears it: the bang happened in the game's world.

*[Animals with their own minds](<https://professoroops.com/en/inside/creatures/>)*

## Figures appear the moment the note plays, and a few classic shapes are left out, to fit a tablet

A real Chladni plate is a hard problem in mechanics. A child with a tablet needs the figure to appear, change with the note and the press point, and sort sand from flour, within a few milliseconds a frame. Here is what we keep and what we let go.

**In real life.** A plate's shapes come from a fourth-order equation, with free edges that don't give simple products

**In the game.** Products of simple cosine stripes with a plate's frequency law: a hybrid of membrane shapes and plate frequencies

**Why that's enough.** Closed form, no solver, and resonance, press point and more lines higher up all follow. The classic low figures, such as the X on a square plate, are lost: low notes give straight stripes

**In real life.** Waves build up, travel and ring down

**In the game.** A steady-state map, on and off instantly

**Why that's enough.** A sheet rings at hundreds of hertz, far beyond 60 steps a second. No build-up or ring-down, and something heavy lying on the sheet doesn't change the figure

**In real life.** Acceleration rises with frequency, and a grain needs more than 1 g to leave a plate

**In the game.** Strength doesn't depend on the note; a game "g" with its own bounce threshold

**Why that's enough.** Volume stays a simple dial and every clean note is equally rewarding. The units are the game's, not real g

**In real life.** Grains fly ballistically and land one by one

**In the game.** A height field: a share of each cell moves one cell per turn, toward lower shaking

**Why that's enough.** Works at full-page scale on a tablet. Grains don't fly, and speed depends on how hard it shakes, not how steep the slope is

**In real life.** Fine powder rides air currents above the plate

**In the game.** The same rule with its sign flipped, at a slower rate; the air isn't read

**Why that's enough.** The right result for almost nothing. A fan blowing over the sheet doesn't change a flour figure through this rule

**In real life.** Water on a shaken plate forms Faraday waves, at half the driving rate

**In the game.** A drawn, slowly moving ripple pattern, as a height offset for the renderer only

**Why that's enough.** You see a grid of ripples where it shakes. The water itself doesn't move, except that very hard shaking throws spray

**In real life.** Sound is a pressure wave that travels, echoes and is blocked

**In the game.** One patch of noise that fades with distance and dies away in a fraction of a second; the speakers play mono

**Why that's enough.** Creatures need "how loud, and from where". No echoes, no sound shadows, and a bang on the left isn't heard on the left

**In real life.** The note a speaker plays is the note the plate rings at

**In the game.** Two scales on one slider: a pleasant range of notes for the ear, a wider range for the model sheet

**Why that's enough.** Pleasant notes and a full range of figures. Pitch and line count rise together, but the note isn't the sheet's frequency