An independent nonprofit research institute in Austin, Texas.

We are deriving reality.

Physics describes what happens. We ask why it has to happen that way. We start from a fact that every question already uses, that some things can be told apart, and prove what follows, each result under its stated conditions. One public list holds what reality has to account for. Each result is marked on it as it is derived.

The list today One square for each thing reality has to account for.

693

of 4,280 derived, in full or given a stated premise.Counted from the public record, 11 November 2026, 8:53 AM CT

  • 78 derived in full Proved in full from the foundation.
  • 615 derived, given a premise Proved, given a stated premise.
  • 763 partly derived Part of the result is proved.
  • 28 open walls The foundation does not decide this. Two models agree on everything below it and differ here.
  • 2,796 not yet derived The work has not reached this item yet.

78 are derived in full and 615 given a stated premise.

What you are looking at. Every square is one thing the structure of reality has to account for, from counting and the golden ratio to proteins and minds. A square fills in when its result is derived from the foundation. The list runs outward in its own order, from its first domain at the centre to its last at the edge. Point at a square to see its name; select it to open it on the map. Open the map · What the colours mean, on the map

Every square is placed and counted in your browser by 735 bytes of machine code. Why machine code: so that nothing is hidden. The bytes are printed in full at the foot of this page, and every count here comes out of them. Read them

Film

The idea, in a film.

Film · The Idea · 2 min 23 s

Research

Peer-reviewed and published papers.

Each designed page shows one paper’s result working in your browser. It also tells you the question the paper answers and who asked it first, and says what the result means for the structure of reality.

The journals: The Journal of Chemical Physics, Journal of Statistical Mechanics: Theory and Experiment, AIP Advances, Entropy, Mathematics, Advances in Pure Mathematics, Symmetry, Molecules, Axioms, Mathematical and Computational Applications and Foundations.

Open The Papers

Where the work meets measurement

Each of these four pages sets what a paper computes beside measurements.

Our people

Different disciplines. A shared ambition.

Our work connects mathematical foundations with molecules, plasmas, light and computation. The team brings the expertise needed to move between a formal result and a physical experiment.

Our Science · Feature pages

One part of the structure on each page, working live.

Seven pages. Each takes one part of the structure and shows it at work.

Where the derivation starts See the five answers work

Collaborate with us

Bring a question worth solving.

Your message goes by email to Jonathan Washburn and Emma Tully.

Research together

Bring a mathematical idea or an experiment that could advance the work.

Discuss a research idea

Explore a partnership

Find where our work in medicine or quantum computing could connect with yours.

Start a conversation

Support the institute

Gifts from individuals and foundations fund the research.

Ways to give

The engine of this page

Every count on this page, in 735 bytes of machine code.

In plain words: these are the bytes that do this page’s computing, printed in full so that nothing is hidden. Every count of the list on this page comes out of them, and so does the place of every square.

The 735 bytes below compute the first five answers of the derivation, each from the condition that fixes it, find the golden turn from the ratio, give every square of the list its place and count the list, status by status. The page is laid out by the ratio they find. The five answers are shown working, one at a time, on a page of their own. The proofs that each answer is the only one its conditions allow are in the worked examples on the overview.

More about the bytes: how they are written, the two values typed into them, and how they lay out the page

They are written directly as WebAssembly bytes, the machine code of the virtual machine built into every modern browser, with no compiler and no library. Your browser runs exactly these bytes. The function that computes the first answers takes no input: its signature, the three bytes on black below, says no parameters and no results.

Two values are typed into the instructions: a 0 and a 1. They are the five bytes on black where that function begins: put a 0, put a 1, do they differ? They are compared once and never used again. The unit, two, the half, every count and every ratio are made from the answer. Every other number an instruction carries is an address, where to read or write, or part of the instruction’s own form.

The page is laid out by what the bytes return. On a wide screen the words and the list share the width in the ratio 1 to φ. On every screen each square of the list sits one golden turn, 1/φ² of a full turn, on from the square before it, at a distance that grows as the square root of its place in the list. Both φ and the turn are found by the bytes before the page is drawn.

A short script on this page, with no library, can carry out these same bytes one instruction at a time. It takes over on a device that declines WebAssembly. Otherwise your browser’s own engine runs them at full speed.

00 61 73 6d 01 00 00 00 01 12 04 60 01 7c 01 7c 60 00 00no input60 01 7f 01 7f 60 01 7f 00 03 05 04 00 01 02 03 05 03 01 00 04 07 27 05 03 6d 65 6d 02 00 04 63 6f 73 74 00 00 06 64 65 72 69 76 65 00 01 05 74 61 6c 6c 79 00 02 05 70 6c 61 63 65 00 03 0a 8b 05 04 1b 01 01 7f the cost20 00 20 01 2b 03 08 20 00 a3 a0 20 01 2b 03 10 a2 20 01 2b 03 08 a1 0b 98 02 02 06 7c 0a 7f the distinction41 00 41 01 47the two typed-in values, told apart21 07 20 06 20 07 36 02 00 counting20 06 20 07 20 07 6a 22 08 36 02 04 20 06 20 07 b8 22 00 39 03 08 20 06 20 00 20 00 20 00 a0 22 01 a3 22 02 39 03 10 the cost20 06 20 01 10 00 39 03 18 20 06 20 02 10 00 39 03 20 20 06 20 00 10 00 39 03 28 the golden ratio20 00 21 03 20 01 21 04 02 40 03 40 20 03 20 04 a0 20 02 a2 22 05 20 03 61 0d 01 20 05 20 04 61 0d 01 20 09 20 07 6a 21 09 20 05 20 05 a2 20 00 20 05 a0 63 04 40 20 05 21 03 05 20 05 21 04 0b 0c 00 0b 0b 20 06 20 04 39 03 30 20 06 20 09 36 02 38 the cost20 06 20 04 10 00 39 03 40 the golden turn20 06 20 00 20 04 20 04 a2 a3 39 03 48 03 40 space20 0a 20 07 6a 22 0a 20 08 6b 20 07 47 0d 00 0b 20 06 20 0a 36 02 3c 03 40 eight states20 0b 20 07 6a 22 0b 68 22 0d 20 0a 20 07 6b 22 0e 20 0d 20 0e 49 1b 21 0d 20 0c 20 07 20 0d 74 73 22 0c 20 07 20 0c 74 20 0f 72 21 0f 0d 00 0b 20 06 20 0f 69 36 02 50 20 06 20 0b 36 02 54 0b 78 01 05 7f counting20 03 28 02 00 22 04 20 04 6a 21 05 20 03 20 03 36 02 60 20 03 20 03 36 02 64 20 03 20 03 36 02 68 20 03 20 03 36 02 6c 20 03 20 03 36 02 70 20 03 20 03 36 02 74 02 40 03 40 20 01 20 00 4f 0d 01 20 01 2d 00 80 20 20 05 74 22 02 20 02 28 02 60 20 04 6a 36 02 60 20 01 20 04 6a 21 01 0c 00 0b 0b 20 03 20 01 36 02 74 20 03 28 02 60 20 03 28 02 64 6a 0b d9 01 02 0b 7c 05 7f the golden turn20 0e 2b 03 08 21 09 20 0e 2b 03 10 21 0a 20 0e 28 02 00 22 0f 20 0f 20 0f 6a 74 21 10 20 0e 2b 03 48 22 01 20 01 a0 21 01 20 09 21 03 20 09 21 04 03 40 20 01 20 01 a0 22 01 20 09 66 04 40 20 01 20 09 a1 21 01 20 04 20 02 a2 20 05 20 03 a2 a1 20 04 20 03 a2 20 05 20 02 a2 a0 21 05 21 04 0b 20 03 20 0a a2 20 09 20 02 a0 20 0a a2 9f 22 02 a3 21 03 20 01 20 0b 62 0d 00 0b a place for every square20 09 21 06 02 40 03 40 20 0c 20 00 4f 0d 01 20 0c b8 9f 21 08 20 0c 20 10 74 22 0d 20 06 20 08 a2 39 03 80 80 02 20 0d 20 07 20 08 a2 39 03 88 80 02 20 06 20 04 a2 20 07 20 05 a2 a1 20 06 20 05 a2 20 07 20 04 a2 a0 21 07 21 06 20 0c 20 0f 6a 21 0c 0c 00 0b 0b 0b

Dark bytes do the step named in front of them. Grey bytes are the frame: the file’s header, the loops and the ends. Bytes on black are the signature that says no input, and the two typed-in values.

The eight annotated listings: every instruction of the 735 bytes, with what it does

00 · The distinction

Two things, a 0 and a 1, told apart. The answer is the mark.

007841 00i32.const 0
007a41 01i32.const 1
two things are typed in: a 0 and a 1
007c47i32.ne
do they differ?
007d21 07local.set one
they do. The answer, 1, is the mark
007f20 06local.get z
008120 07local.get one
008336 02 00i32.store offset=0
write the mark in the record

01 · Counting

Two, the unit, two units and a half, all made from the mark.

008620 06local.get z
008820 07local.get one
008a20 07local.get one
008c6ai32.add
008d22 08local.tee two
the mark and one more: two
008f36 02 04i32.store offset=4
write two
009220 06local.get z
009420 07local.get one
0096b8f64.convert_i32_u
009722 00local.tee unit
the mark as a length: the unit
009939 03 08f64.store offset=8
write the unit
009c20 06local.get z
009e20 00local.get unit
00a020 00local.get unit
00a220 00local.get unit
00a4a0f64.add
00a522 01local.tee twof
two units
00a7a3f64.div
00a822 02local.tee half
the ratio of one to two: a half
00aa39 03 10f64.store offset=16
write the half

02 · The cost

For any ratio. The run takes it at two, at a half and at a match.

00ad20 06local.get z
00af20 01local.get twof
00b110 00call cost
the cost of a ratio of two
00b339 03 18f64.store offset=24
write it
00b620 06local.get z
00b820 02local.get half
00ba10 00call cost
the cost of a ratio of one half
00bc39 03 20f64.store offset=32
write it
00bf20 06local.get z
00c120 00local.get unit
00c310 00call cost
the cost of a match
00c539 03 28f64.store offset=40
write it

The cost itself

005920 00local.get x
005b20 01local.get z
005d2b 03 08f64.load offset=8
006020 00local.get x
0062a3f64.div
0063a0f64.add
x + 1/x: the ratio and its mirror together
006420 01local.get z
00662b 03 10f64.load offset=16
0069a2f64.mul
half of that
006a20 01local.get z
006c2b 03 08f64.load offset=8
006fa1f64.sub
less one: a match, x = 1, costs nothing
00700bend
hand the cost back

03 · The golden ratio

Halve the interval until level 2 meets the join of levels 0 and 1; then the cost of one step, and the golden turn.

00c820 00local.get unit
00ca21 03local.set lo
00cc20 01local.get twof
00ce21 04local.set hi
the ratio lies between 1 and 2
00d002 40block
00d203 40loop
a loop begins: one pass for each halving
00d420 03local.get lo
00d620 04local.get hi
00d8a0f64.add
00d920 02local.get half
00dba2f64.mul
00dc22 05local.tee mid
try the ratio halfway between
00de20 03local.get lo
00e061f64.eq
00e10d 01br_if 1
00e320 05local.get mid
00e520 04local.get hi
00e761f64.eq
00e80d 01br_if 1
stop when the interval can no longer be halved
00ea20 09local.get n
00ec20 07local.get one
00ee6ai32.add
00ef21 09local.set n
one more halving: one more mark
00f120 05local.get mid
00f320 05local.get mid
00f5a2f64.mul
level 2: two steps up from level 0
00f620 00local.get unit
00f820 05local.get mid
00faa0f64.add
the join: level 0 plus level 1
00fb63f64.lt
does level 2 fall short of the join?
00fc04 40if
00fe20 05local.get mid
010021 03local.set lo
it falls short: the ratio is larger
010205else
010320 05local.get mid
010521 04local.set hi
it does not: the ratio is no larger
01070bend
the interval is half as wide
01080c 00br 0
back to the start of the loop
010a0bend
010b0bend
the loop is over
010c20 06local.get z
010e20 04local.get hi
011039 03 30f64.store offset=48
write the ratio
011320 06local.get z
011520 09local.get n
011736 02 38i32.store offset=56
write the number of halvings
011a20 06local.get z
011c20 04local.get hi
011e10 00call cost
the cost of one step of the ladder: the cost, at this ratio
012039 03 40f64.store offset=64
write it
012320 06local.get z
012520 00local.get unit
012720 04local.get hi
012920 04local.get hi
012ba2f64.mul
012ca3f64.div
the golden turn: 1 / ratio² of a full turn
012d39 03 48f64.store offset=72
write the turn

04 · Space

Count dimensions up to the one in which a loop can be linked with a loop.

013003 40loop
a loop begins: one pass for each dimension
013220 0alocal.get d
013420 07local.get one
01366ai32.add
013722 0alocal.tee d
one more dimension: one more mark
013920 08local.get two
013b6bi32.sub
what a loop can be linked with there has d − 2 dimensions
013c20 07local.get one
013e47i32.ne
013f0d 00br_if 0
go on until that is 1: another loop
01410bend
the loop is over
014220 06local.get z
014420 0alocal.get d
014636 02 3ci32.store offset=60
write the dimension

05 · Eight states

Walk the settings of the switches, one flip per tick, and count the ticks home.

014903 40loop
a loop begins: one pass for each tick
014b20 0blocal.get k
014d20 07local.get one
014f6ai32.add
015022 0blocal.tee k
one more tick: one more mark
015268i32.ctz
015322 0dlocal.tee j
the lowest place of the count that just changed
015520 0alocal.get d
015720 07local.get one
01596bi32.sub
015a22 0elocal.tee top
015c20 0dlocal.get j
015e20 0elocal.get top
016049i32.lt_u
01611bselect
016221 0dlocal.set j
that switch flips; past the last switch, the last one flips
016420 0clocal.get s
016620 07local.get one
016820 0dlocal.get j
016a74i32.shl
016b73i32.xor
016c22 0clocal.tee s
flip that one switch
016e20 07local.get one
017020 0clocal.get s
017274i32.shl
017320 0flocal.get seen
017572i32.or
017621 0flocal.set seen
mark this setting as visited
01780d 00br_if 0
a switch is still on: not home yet
017a0bend
every switch is off: home
017b20 06local.get z
017d20 0flocal.get seen
017f69i32.popcnt
018036 02 50i32.store offset=80
write the number of settings visited
018320 06local.get z
018520 0blocal.get k
018736 02 54i32.store offset=84
write the ticks it took to come home
018a0bend
the end of the function

Counting the list

One mark is added for each square, and one for its status.

018f20 03local.get z
019128 02 00i32.load offset=0
019422 04local.tee one
019620 04local.get one
01986ai32.add
019921 05local.set two
the mark, read from the record, and two
019b20 03local.get z
019d20 03local.get z
019f36 02 60i32.store offset=96
01a220 03local.get z
01a420 03local.get z
01a636 02 64i32.store offset=100
01a920 03local.get z
01ab20 03local.get z
01ad36 02 68i32.store offset=104
01b020 03local.get z
01b220 03local.get z
01b436 02 6ci32.store offset=108
01b720 03local.get z
01b920 03local.get z
01bb36 02 70i32.store offset=112
01be20 03local.get z
01c020 03local.get z
01c236 02 74i32.store offset=116
start every count at nothing
01c502 40block
01c703 40loop
01c920 01local.get k
01cb20 00local.get n
01cd4fi32.ge_u
01ce0d 01br_if 1
until every square has been counted
01d020 01local.get k
01d22d 00 80 20i32.load8_u offset=4096
the status of this square in the record
01d620 05local.get two
01d874i32.shl
01d922 02local.tee p
01db20 02local.get p
01dd28 02 60i32.load offset=96
01e020 04local.get one
01e26ai32.add
01e336 02 60i32.store offset=96
that status's count: one more mark
01e620 01local.get k
01e820 04local.get one
01ea6ai32.add
01eb21 01local.set k
the count of squares: one more mark
01ed0c 00br 0
01ef0bend
01f00bend
01f120 03local.get z
01f320 01local.get k
01f536 02 74i32.store offset=116
write the count of squares
01f820 03local.get z
01fa28 02 60i32.load offset=96
01fd20 03local.get z
01ff28 02 64i32.load offset=100
02026ai32.add
derived in full plus derived given a premise
02030bend

A place for every square

The golden turn, built out of halved quarter turns; then square k sits the square root of k from the centre, one golden turn on from the last.

020b20 0elocal.get z
020d2b 03 08f64.load offset=8
021021 09local.set unit
021220 0elocal.get z
02142b 03 10f64.load offset=16
021721 0alocal.set half
the unit and the half, read from the record
021920 0elocal.get z
021b28 02 00i32.load offset=0
021e22 0flocal.tee one
022020 0flocal.get one
022220 0flocal.get one
02246ai32.add
022574i32.shl
022621 10local.set four
the mark, and four: the mark shifted by two
022820 0elocal.get z
022a2b 03 48f64.load offset=72
022d22 01local.tee g
022f20 01local.get g
0231a0f64.add
023221 01local.set g
the golden turn, written in half turns
023420 09local.get unit
023621 03local.set hs
start with a quarter turn
023820 09local.get unit
023a21 04local.set rc
and with no turn made yet
023c03 40loop
023e20 01local.get g
024020 01local.get g
0242a0f64.add
024322 01local.tee g
024520 09local.get unit
024766f64.ge
does the golden turn contain this piece?
024804 40if
024a20 01local.get g
024c20 09local.get unit
024ea1f64.sub
024f21 01local.set g
025120 04local.get rc
025320 02local.get hc
0255a2f64.mul
025620 05local.get rs
025820 03local.get hs
025aa2f64.mul
025ba1f64.sub
025c20 04local.get rc
025e20 03local.get hs
0260a2f64.mul
026120 05local.get rs
026320 02local.get hc
0265a2f64.mul
0266a0f64.add
026721 05local.set rs
026921 04local.set rc
it does: add this piece to the turn
026b0bend
026c20 03local.get hs
026e20 0alocal.get half
0270a2f64.mul
027120 09local.get unit
027320 02local.get hc
0275a0f64.add
027620 0alocal.get half
0278a2f64.mul
02799ff64.sqrt
027a22 02local.tee hc
027ca3f64.div
027d21 03local.set hs
halve the piece: a square root, and no π
027f20 01local.get g
028120 0blocal.get fz
028362f64.ne
02840d 00br_if 0
until nothing of the turn is left
02860bend
028720 09local.get unit
028921 06local.set px
the first direction
028b02 40block
028d03 40loop
028f20 0clocal.get k
029120 00local.get n
02934fi32.ge_u
02940d 01br_if 1
until every square has a place
029620 0clocal.get k
0298b8f64.convert_i32_u
02999ff64.sqrt
029a21 08local.set r
distance from the centre: the square root of the count
029c20 0clocal.get k
029e20 10local.get four
02a074i32.shl
02a122 0dlocal.tee a
02a320 06local.get px
02a520 08local.get r
02a7a2f64.mul
02a839 03 80 80 02f64.store offset=32768
02ad20 0dlocal.get a
02af20 07local.get py
02b120 08local.get r
02b3a2f64.mul
02b439 03 88 80 02f64.store offset=32776
write this square's place
02b920 06local.get px
02bb20 04local.get rc
02bda2f64.mul
02be20 07local.get py
02c020 05local.get rs
02c2a2f64.mul
02c3a1f64.sub
02c420 06local.get px
02c620 05local.get rs
02c8a2f64.mul
02c920 07local.get py
02cb20 04local.get rc
02cda2f64.mul
02cea0f64.add
02cf21 07local.set py
02d121 06local.set px
turn by one golden turn for the next square
02d320 0clocal.get k
02d520 0flocal.get one
02d76ai32.add
02d821 0clocal.set k
02da0c 00br 0
02dc0bend
02dd0bend
02de0bend