EIS (Engineering Impact Signal) is a CLI tool that reads the structural shape an engineer left on a codebase, using only data from git log and git blame. Gravity is its relational reading: a structural shape passed through two honest gates, so neither surviving code alone nor catalysis alone can mint it.
The two gates are what make gravity relational rather than a tally of output:
survGate (Robust Survival) — did the code last under others' pressure? Robust survival counts only lines surviving in modules where authors other than you actively commit. Dead-corner code and self-churned code do not qualify.
catGate (Catalysis) — did others build on your surviving foundation? It is the one axis necessarily zero for a solo author, so it witnesses that the structure observably leans on someone.
For cross-language comparison we use Gravity Concentration — the share of a universe's total gravity held by its top-3 engineers. A high value does not read as power; it reads as a structure that observably rests on very few load-bearing names.
2. Cross-Language Analysis — Physical Laws Are Not Uniform
Different languages produce different "physical laws." Type system expressiveness, framework culture, and architectural concentration.
We classified 29 OSS repositories into 5 categories and compared the distribution of structural authority.
Average share of a universe's total gravity held by its top-3 engineers, by category. Higher values read as a structure resting on very few load-bearing names.
Framework-driven
61.9%
Dynamic / Structural
60.3%
Expressive
54.9%
Go (Self-structured)
50.1%
Systems (C/C++)
30.0%
Under the two-gate reading, framework-driven projects rest on the fewest names, and Systems (C/C++) on the most.
Gravity registers only where code survives under others' pressure and others build on it, so a category's concentration reads whether a few creator-architects still hold the load-bearing role. Inside the framework category that ranges widely — from Rails, where the field tilts toward no one (9.8%), to Spring Boot and FastAPI, where almost the whole structure funnels through one or two (97.2%, 94.5%).
Systems projects (C/C++) and Go spread the load across many long-lived maintainers, so no tiny group carries it. Dynamic, Expressive, and Go all land within a dozen points of each other in the middle; the one clean signal is Systems / C++ standing apart at the bottom. Concentration tracks whom the structure still leans on, not which language was written first — being first earns nothing once others stop pressing on the code.
Three Structural Authority Modes
Across the 29 universes, three patterns recur in where the surviving structure ends up leaning. The mode is not set by the language alone — it is what the two gates read once activity is filtered out.
Architect-built (Go)
Structure is built by people from scratch, through explicit interfaces. Several long-lived maintainers each carry real, non-dominant gravity, so the load is shared and concentration sits mid-pack (50.1%). Terraform, Kubernetes, Prometheus read this way.
Type-distributed (compilers)
In the language compilers themselves, structure is embedded in types and the load spreads across many hands — Rust 27.6%, Scala 37.3%, Scala 3 38.9%. No single name the system tilts toward; design history runs through everyone who works in the type machinery.
Framework-funneled (Rails ↔ Spring Boot)
When structure is absorbed by the framework, the category spreads the widest internally — from Rails, where the field tilts toward no one (9.8%), to Spring Boot's near-singular load (97.2%). As a category, the one that rests on the fewest names (61.9%).
3. Rails vs Laravel — Same Category, Opposite Physics
Both belong to the "Framework-driven" category. Both are popular frameworks with legendary creators.
Yet their Gravity physics are completely opposite.
Rails
Multi-Architect Civilization
Engineers6,056
Top10 Design (avg)57.0
Leader Gravity4.0
Gravity Conc. (top-3)9.8%
Design > 409 people
Laravel
Kingdom of the Creator
Engineers4,149
Top10 Design (avg)12.0
Leader Gravity65.1
Gravity Conc. (top-3)38.0%
Design > 402 people
Design Authority Distribution
Rails — 10 architects above 35, 9 above 40
#1
100.0
#2
96.8
#3
89.5
#4
89.2
#5
58.8
#6
58.7
#7
51.7
#8
49.1
#9
48.6
── Design 40 Threshold ──
#10
39.0
Laravel — the sole author's monopoly
#1
100.0
#2
46.4
── All other Top10 contributors: Design < 7 ──
#3
6.3
#4
4.9
Same Framework-driven category. Opposite governance physics.
Rails reads as a multi-architect civilization. 9 of the top 10 authors carry Design above 40 (the highest at 96.8), and not one of them sits first. The top author set the gravitational center, yet the top gravity scores compress (4.0, 3.8, 3.6) and the top-3 hold only 9.8% of the total — the lowest of all 29 universes. The structure tilts toward no one in particular.
Laravel reads as a creator's kingdom — the rare case where both gates open for one person. the sole author is the only one who holds Catalysis 100 and RobustSurvival 78.4 at once: others build on his foundation, and his code endures in modules where others keep committing. His gravity lands at 65.1, about ten times the next author (6.5). Coherent, and resting on one chair.
The question isn't which is better, but what produced the difference — and whether Laravel's field lines stay this concentrated, or spread the way Rails' did over twenty years.
4. esbuild — A Universe of One (Gravitational Singularity)
124 contributors pass through, but one person holds 77.0% of the top-3 structural gravity — and is the only author the surviving structure leans on at all.
77.0%
Gravity Concentration (top-3)
100
the sole author's Design / Breadth / Indisp
4,202
the sole author's commits
0
the sole author's Robust Survival
Where esbuild's 77.0% Sits
swc
92.0%
esbuild
77.0%
express
60.3%
vite
59.9%
react
31.4%
rust
27.6%
kubernetes
27.5%
rails
9.8%
The shape is perfect; what is missing is the relational evidence.
the sole author shaped the whole bundler across 4,202 commits — Design, Breadth and Indispensability all at 100 — and he is the only author the surviving structure leans on at all. Yet the telescope returns a gravity of 15.0, not 100: in a one-person universe no one else ever commits inside his modules, so robust survival reads 0, the survival gate holds at its floor, and the field collapses inward. Ownership without contest cannot mint gravity. The 77.0% concentration is not a verdict on power — it is the visible trace of a structure that nothing external has yet leaned on. It is the purest singularity in the map (swc edges it on density), and it leaves one quiet question: if no other hand has ever carried this code under pressure, would anyone catch it if that author quietly left?
5. React — A Decade of Generational Transition
React, with 1,927 engineers involved, has passed through a genuine architect succession over a decade.
The per-period timeline below reads each window on its own, and the structural chair moves between three authors: Contributor A (virtual DOM era) → Contributor B (Fiber + Hooks era) → Contributor D (Server Components era).
1,927
Engineers
31.4%
Gravity Concentration (top-3)
3
Structural Generations
12 yrs
Tracking Period
Generational Handover of the Structural Seat
2013-2014 — The Virtual-DOM Era
Contributor A held the early structural lead (virtual DOM era) — Architect in 2013 (gravity ~15), settling to Anchor in 2014 (~6). The author who gave the virtual DOM its first shape, before the project grew past them.
2017-2022 — The Fiber + Hooks Era
Contributor B is the dominant structural figure across these years (Fiber + Hooks era) — Architect gravity 68 (2018) → 65 (2020) → 77 (2021). Contributor C holds a seat alongside them as Cleaner/Anchor (peak ~46 in 2018). The Reconciler was rewritten as Fiber and Hooks landed; the structural load sat squarely on Contributor B while Contributor C held the developer-facing surface. Contributor C departed in 2024.
2023 & 2025 — The Server Components Era
Contributor D takes the seat (Server Components era) — Architect gravity 89 (2023), settling to Anchor 38 (2025). Server Components, the new rendering pipeline. In the static full-history reading, Contributor D leads React's gravity (~9.9, Anchor): others plainly built on them (Catalysis 100) and the codebase still leans on them (Indispensability 100). Yet the gravity stays modest, because the Reconciler that was laid down now sits largely undisturbed — little of that code survives under others' live churn.
Now — The Next Seat Being Set
The React Compiler shows up in Design — Contributor E ranks #1 by Design, with Contributor F alongside. Their relational gravity is still low: the work is recent, and others have not yet built on it under pressure. This reads as the next chair being set, not yet load-bearing.
React reads as a genuine succession.
Contributor A (virtual DOM era) → Contributor B (Fiber + Hooks era) → Contributor D (Server Components era) → the next chair now being set.
When one author steps back, the next inherits the structure others lean on. In the static full-history reading Contributor D leads at ~9.9, and the top-3 hold 31.4% of gravity — one author carries the load at a time, but the seat has moved cleanly across three authors, and no single name dominates the field.
The reading is quiet but consistent: a contributor whose code sits at the core of the design registers structural gravity, while the newest design work waits on others to press on it before it can read as load-bearing. The telescope reads where the system still leans, not how much anyone wrote.
6. Validity of EIS — Does Intuition Match Data?
Gravity is computed solely from git log and git blame. It cannot see RFCs or design documents.
Yet under the two-gate reading, the names that rise to the top of each universe are the ones the community would name as the people the system rests on.
64.2%
Avg Architect Recall (Tier 1)
41.0%
Avg Top-10 Overlap w/ GitHub
0.442
Avg Spearman ρ
355
Hidden Architects found
Validation Item
Gravity Reading
Community Intuition
Match
Phoenix's center
Top author gravity 88.2, both gates open (Architect)
matches who the community sees as the central designer
Match
Laravel's creator
Top author gravity 65.1, ~10× the #2
matches the "single creator" view
Match
swc's author
Top author gravity 89.2 (Architect)
matches the "single compiler author" view
Match
Polars' lead
Top author gravity 65.3 (Anchor)
matches the "project lead" view
Match
ESLint's maintainer
Top author gravity 77.1 (Architect)
matches the "current maintainer" view
Match
Rails' design spread
Top-10 Design avg 57.0, 9 above 40
matches the "deep core team" view
Match
esbuild's solo nature
77.0% concentration, the only load-bearing author
matches the "solo build" view
Match
Kubernetes' distribution
Gravity Conc. 27.5%, spread across many
matches the "huge community" view
Match
Beyond "it feels about right."
Gravity is not complete. RFC discussions, design conversations, mentoring through code review — this dark matter stays unobservable to git blame.
Yet across the 29 universes, the average recall of a project's Tier-1 architects is 64.2%, and the rank correlation with community standing holds at ρ 0.442 — and the map surfaces 355 hidden architects whom no maintainer list names but whose code the system still rests on.
Read across 29 repositories and 51,321 engineers, the structure a system leans on differs systematically across language families — and the same instrument reads it the same way each time. That consistency is the part experience and intuition alone could not put a number on.
7. Conclusion
What a System Leans On Is Observable — and It Differs by Universe
Gravity is relational. It registers only where the structure observably leans on someone — code that survives under others' pressure, a foundation others build on. Neither surviving code alone nor catalysis alone can mint it; both gates have to stay open.
Read that way, concentration varies by ~2.1x across language families — from Framework-driven (61.9%) resting on the fewest names to Systems C/C++ (30.0%) spread across the most. Go, which the old additive model ranked highest, now sits mid-pack at 50.1%.
Three modes recur — architect-built (Go), type-distributed (the language compilers), framework-funneled (Rails ↔ Spring Boot) — and the same category can hold both extremes: Rails tilts toward no one (9.8%), Spring Boot onto almost one (97.2%). esbuild is a singularity the instrument declines to call gravity, because no one else stands on the code. React reads as a genuine succession — the seat passes Contributor A → B → D — across a decade.
The map is not a leaderboard. It leaves one question open: once the noise of activity is filtered out, what does a system actually lean on — and would anyone notice if that quietly left?
All 29 Repositories
Repository
Category
Language
Engineers
Top Gravity
Grav Conc
spring-boot
Framework
Java
1,430
50.2
97.2%
prettier
Dynamic
JS
782
87.1
95.3%
fastapi
Framework
Python
861
15.0
94.5%
swc
Expressive
Rust
349
89.2
92.0%
duckdb
Systems
C++
618
81.7
83.5%
polars
Expressive
Rust
665
65.3
78.4%
esbuild
Go
Go
124
15.0
77.0%
nest
Framework
TS
638
18.9
68.1%
eslint
Dynamic
JS
1,153
77.1
66.8%
prometheus
Go
Go
1,159
35.8
64.4%
phoenix
Framework
Elixir
1,343
88.2
63.5%
express
Dynamic
JS
378
8.3
60.3%
vite
Dynamic
TS
1,204
90.7
59.9%
terraform
Go
Go
2,121
27.1
56.2%
argo-cd
Go
Go
1,832
13.7
50.9%
superset
Dynamic
Python/TS
1,433
20.5
47.7%
grafana
Go
Go/TS
2,715
28.2
45.1%
scala3
Expressive
Scala 3
895
7.2
38.9%
laravel
Framework
PHP
4,149
65.1
38.0%
scala
Expressive
Scala
709
9.7
37.3%
ClickHouse
Systems
C++
2,189
12.2
33.9%
react
Dynamic
JS
1,927
9.9
31.4%
loki
Go
Go
1,272
12.1
29.8%
rust
Expressive
Rust
7,215
10.5
27.6%
kubernetes
Go
Go
4,510
16.3
27.5%
arrow
Systems
C++
1,369
3.7
14.8%
rails
Framework
Ruby
6,056
4.0
9.8%
redis
Systems
C
848
3.8
9.6%
envoy
Systems
C++
1,377
4.0
7.9%
On Names
This map is anonymous by default. We observe role and structure, but we do not rank named individuals without their consent — the same disclosure-firewall principle EIS applies everywhere.
Your gravity is yours. So — if you are one of the people observed here, you can join EIS's open research with your GitHub account. You decide whether to claim your gravity under your name, show your name only, stay anonymous, or drop out entirely. The default stays anonymous. Every name that appears in the published research belongs to someone who chose to take part.