Logos of Aether: A Measurement-Theoretic Physics Engine in Rust/WGPU (v2.2.1)
I’ve been “winging it” for a year trying to formalize a theory that has been bouncing around my head since high school. After years of post-graduation struggle and feeling like I was failing at life, I finally funneled that obsession into 566 pages of theory and a working simulation engine. This is Logos-Core.
The goal: To prove the universe doesn’t compute with Zero or Infinity, but with Ratios in a resource-constrained substrate called the Monadic Plenum.
🛠 The Stack
- Language: Rust (strictly leveraging zero-cost abstractions for the
PlenumRealtype). - Compute: WGPU / WGSL (the universe as a
GL_RGBA32Fstate matrix). - Architecture: Ping-Pong Buffer Causality (strict temporal separation between frames).
The Core Axiom: $\pi$-Saturation
Standard physics breaks at high densities because linear addition ($1+1=2$) leads to singularities. My engine implements Plenum Addition ($\oplus$). Just as $c$ is the speed limit, $\pi$ is the saturation limit for information density.
$$x \oplus y = \frac{x + y}{1 + \frac{xy}{\pi^2}}$$
In v2.2.1, I’ve verified this on-hardware. While small increments appear linear, self-addition ($x \oplus x$) demonstrates a hard saturation at $\pi$, rendering singularities mathematically impossible at the architectural level.
The Teeter-Totter (Causal Budgeting)
We replace “Uncertainty” with Resource Constraints. The engine enforces a zero-sum trade-off between Temporal Resolution ($d_{self}$) and Spatial Resolution ($d_{world}$):
$$d_{self} \cdot d_{world} \le \pi c$$
If a Monad (pixel) requires high spatial precision, its internal update frequency (Time) must drop. In this architecture, Inertia is literally processing latency.
v2.2.1 “Soliton” Features:
- Self-Propagating Solitons: High-pressure waves that wrap and interfere without dissipation.
- The Chronoscope: A real-time GPU visualizer (
cargo run --example chronoscope) for observing Aether ripple in a ping-pong buffer. - Singularity Prevention: No renormalization required; the math is self-braking.
Strategic Commons Licensing
This project is built to be a common possession of humanity.
- Code (AGPL-3.0): Open source.
- Theory (CC BY-NC-ND 4.0): The 573-page manuscript.
- Math (Public Domain): Truth cannot be enclosed.
Repo: https://github.com/chrisnchips42-blip/logos-core
I’ve spent a long time fucking around in life, doing shit like trying to die and wasting a marriage. But this has bounced around my head 15 years and I think what I have is solid. I’m looking for feedback on the WGSL compute kernels and the Plenum_pingpong implementation. If the universe is a computation, it has a hardware limit—this is my attempt to map it.
The high level idea (uncertainty principle looks like we’re on a grid, which feels familiar to programmers) is fine, that’s a common and pretty solid argument for living in a simulation.
The code you’ve written though has very little (actually none, as far as I can see) connection to that idea. Its like you’ve tried to do an experiment in physics but all your code is for a modern art exhibit.
AI is leading you astray here. I have a bachelors in physics, and none of this is actual physics. I suggest setting AI aside and doing this the old fashioned way with textbooks and paper, because the code here isn’t doing anything even remotely related to what you want.
The high level idea (uncertainty principle looks like we’re on a grid, which feels familiar to programmers) is fine, that’s a common and pretty solid argument for living in a simulation.
Is that actually true? AFAIR the uncertainty principle is just a natural outcome of the position being a matter wave, and the momentum being a Fourier transform of that wave; and if a wave is “localized” at one point, its Fourier transform will be “dispersed” (and vice versa, due to the Fourier inverse theorem). A good, but vastly simplified analogy is that it’s impossible to precisely define the audio frequency of a single sharp clap.
There’s nothing “simulation grid” about that, because a Fourier transform applies to continuous-domain and continuous-variable functions.
Yep that’s right!
I was using “grid” to be more easily understood, but what we really have is quantization. We get plank length from the uncertainty principle, as well as plank time, which is reminiscent of common strategies for reducing the computational requirements of simulations (reduced precision calculations). This pattern is repeated in the quantization of charge, etc.
So you’re right its not a grid. Just a continuous cap on precision. But the point stands, it looks familiar to programmers and is a fair reason to suspect we’re in a simulation. Not proof of course, just a neat little hint.
Hm, you should clue me in. I thought the Planck length being the “minimum” unit of length was more to do with particles with a short wavelength to be comparable to a Planck length would need to have so much energy that they will become black holes, which means it’s not really feasible to investigate anything “happening” at scales smaller than that. So to me it doesn’t feel particularly relevant to the uncertainty principle. But it’s been a long time since my physics courses, so I might be missing some obvious connection.
Yep that’s right, below the plank length you can’t make position measurements without destroying what you’re trying to measure.
And you are right that it can be fully explained without needing to be in a simulation, that is how these were discovered after all. The simulation angle is pretty far outside of the math of respectable physics.
The reason the simulation hypothesis bleeds into the discussion is because its natural to ask “why” things break down at that specific size. Humans don’t like vague answers like “because god likes that number”, we prefer to tell ourselves stories that fit the numbers into physical things in our minds. Just like the Bohr model of the atom was a useful story about how atoms are structured for decades despite not being rigorously proven (and even being firmly disproven nowadays), one story we can tell ourselves to make sense of quantization is to view it as an attempt at limiting precision for computation.
It is only a story at the end of the day though. We don’t really know why physics was set up exactly this way any more than we know why the big bang happened in the first place. Just lots of different peoples guesses, telling plausible stories about the math.
Please seek psychological help. The LLM chatbots are giving you false confidence in your ideas. They are flawed tools that will stroke your ego for the most outlandish, nonsensical ideas. Your closing sentence regarding self-harm and the wasting of a marriage are concerning. Please talk to professionals instead of chatbots.
Harsh, but might be best to heed this advice. You can’t resolve trauma and relationship issues by inventing a physics theory, even if it was correct (which it probably isn’t).
I’m specifically worried about the performance overhead of the PlenumReal wrapper. If anyone has experience with custom algebraic types in high-concurrency Rust, I’d love your thoughts.
I’m gonna say maybe I suck at seeking feedback. Pardon me for trying to present my “theory” I’ve held for 15 years with a decent presentation. But fuck you all for responding to psychotic symptoms with gaslighting. Fucking wow. I work with my psych and am an adult. Thanks for the “concern”. Bunch of fucking nihilists, all of you. Think there’s some vacuum out there to dump your anger into, but here I am taking on your self-hatred as usual. Mind your tone bitch.
I’m glad to hear you’re getting help! Hope you pull through this. I think myself and others are really wishing the best for you, please don’t be offended.
As for your physics theory & code though, I must repeat what others are saying. Stop using LLMs (be it copilot or gemini), they are clouding your thoughts and blurring any original ideas you may have into an incoherent sloppy mess.
Scrap your repo, clear your mind, start over. Don’t have many expectations, most (I’d guess 99%) of amateur physics theories out there turn out to be wrong.
Open a markdown document in a simple editor and write down your ideas, by yourself, with no stupid computer program telling you what to think.
Then take a pen and paper and try to distill your ideas into mathematical formulae, with no stupid computer program (which doesn’t have any real mathematical knowledge or rigor) making up bogus equations.
Then, using that same pen and paper, try to work through a few examples of applying those formulae to specific physical situations. Start simple, don’t try to reproduce the entire universe at all scales at once, maybe start with a finite universe containing a couple of electrons and see how their interactions play out. Don’t let a stupid computer program (which can’t even perform basic arithmetic by itself) make grave mistakes.
If it seems like the model works for a couple very simple examples, try to put it into code. Don’t use Rust or GPUs or even scipy for your first prototype, just write it in pure python. And for the love of all that is good, don’t use LLMs for this either. Just take your formulae from your piece of paper and translate it into python by hand, with no stupid computer program (which can’t even count the number of R’s in a word strawberry) stealing code from others and writing boilerplate instead of describing your original ideas.
Don’t worry about performance for a prototype, if the results it produces are at least interesting, you can worry about optimizations later.
This video is silly but does a good job of conveying how dumb chatbots can actually be especially if you think you’re onto something. Even though your idea makes sense (I don’t know enough about physics to say either way), keep in mind this is the thing that you’re sharing it with. If it’s dumb when asked a dumb question it’s not a good sign for how smart it will be when asked a smart question.
https://www.youtube.com/watch?v=VRjgNgJms3Q
Edit: just remembered about this person recently brought up on a discord server I’m on who was clearly having some chatbot break down over physics in a weird way https://github.com/aaronschutza/Research
This one is particularly obviously nonsensical https://github.com/aaronschutza/Research/blob/main/APH_Quake.pdf
Anyways the point is that AI is absolutely not trustworthy in any way
