Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
There is a strange moment that happens to almost every programmer who reads spiritual literature. Somewhere between the Ra material and a design patterns textbook, the two start to rhyme. Concepts that mystics spent centuries wrapping in poetry suddenly look like architecture diagrams. The soul begins to resemble a class definition. Reincarnation starts to look like session management. The afterlife reads like a well-designed distributed system.
This is not a coincidence, and it is not a trivialization. Software engineering is humanity’s most refined language for describing how information systems behave, and if consciousness researchers like Thomas Campbell are right, reality itself is an information system. When the map and the territory are both made of data, the map gets eerily accurate.
So let us do something unusual. Let us walk through some of the deepest puzzles in metaphysics, from NDE greeters to the seven bodies of the Ra material, and translate each one into the language of code. You may find, as I did, that the translation does not flatten the mystery. It sharpens it.
The Puzzle That Started It All: Who Greets You When You Die?
Near-death experience research has documented the same scene thousands of times. The experiencer leaves the body, moves toward light, and is met by someone they love who has died. Radiation oncologist Jeffrey Long, who has collected decades of accounts through his foundation, notes in his review of NDE evidence that encountering deceased loved ones is one of the most consistent features across cultures, ages, and belief systems.
But here is the puzzle that keeps sincere students of reincarnation up at night. If your grandmother greets you at the threshold, yet reincarnation is real, could she not already be living another life somewhere on Earth? How can she be in two places at once?
In programming, this is not a paradox at all. It is the difference between a class and an instance.
Your Soul Is the Class, Your Life Is an Instance
In object-oriented programming, a class is a template: the complete definition of what something is, with all its properties and capabilities. An instance is a living copy of that template, created from the class and running in the world. Crucially, you can instantiate a class as many times as you like, simultaneously, and no instance conflicts with any other. None of them is the class. They all point back to it.
Now apply that to the greater self. Your grandmother’s oversoul is the class. Her incarnation as your grandmother was one instance. Her possible current incarnation elsewhere is another instance. And the radiant being who meets you in the light? A third instance, spun up by the greater self for exactly that purpose, carrying her full personality and love because every instance inherits everything the class contains.
This also explains something researchers at the University of Virginia’s Division of Perceptual Studies have documented carefully: experiencers sometimes meet deceased people they never knew, or people they did not yet know had died. Emily Williams Kelly’s study of NDEs involving deceased persons found cases where the greeter had a distant relationship with the experiencer, or had died before the experiencer was even born. If greeters were wishful projections, we would expect only beloved, well-known figures. But if the system can instantiate any consciousness whose class definition exists in the larger reality, these anomalies are exactly what we would predict.
It even handles the Jesus problem. Thousands of experiencers report meeting Christ, sometimes on the same day. A single physical person cannot do that. A class can be instantiated without limit.
The Seven Bodies of the Ra Material: A Layered Architecture
The Law of One material takes this further with one of the most detailed descriptions of the multi-body self in any channeled literature. In session 47, Ra describes seven bodies corresponding to the seven rays: the red-ray chemical body, the orange-ray physical complex, the yellow-ray body we inhabit in this density, the green-ray body sometimes seen in séance phenomena, the blue-ray or devachanic body, the indigo-ray etheric body, and the violet-ray body of completeness that some traditions call the Buddha body.
To a software architect, this looks unmistakably like a layered protocol stack. Think of the OSI model that underpins computer networking: seven layers, each providing services to the layer above it, each able to operate without the layers below it once a session is established. When your physical body dies, the lower layers of the stack are torn down, but the session does not end. It simply continues at a higher layer.
You could also read the seven bodies through the decorator pattern, where each layer wraps the previous one and adds capability while preserving the underlying interface. The yellow-ray body decorates the orange, the green decorates the yellow, and so on up the stack. The “you” that persists is not any single wrapper. It is the whole composed object.
The Indigo Body: The Factory That Builds Your Form
One body in Ra’s architecture deserves special attention. In session 51, Ra explains that the indigo-ray body is the “form-maker,” the first body to activate after physical death, and describes it as an analog for intelligent energy: in microcosm, the Logos itself. Ra states that entrance into incarnation requires the activation of this indigo body, because it is the body that molds and shapes all the others.
In design pattern terms, this is a factory. The factory pattern exists precisely so that a system has one dedicated component responsible for constructing new instances: choosing the configuration, allocating the resources, and assembling the object according to specification. Ra even describes the indigo body drawing upon will and wisdom to “choose the appropriate locus and type of experience” for the next incarnation. That is a factory method selecting constructor parameters. The newly dead soul resting in the indigo body between lives is an object returned to the factory, awaiting its next instantiation.
The Veil of Forgetting Is a Sandbox
Why do we not remember our past lives, our greater selves, or the system we came from? Every metaphysical tradition wrestles with the veil. In computing terms, the answer is almost obvious: encapsulation and sandboxing.
A sandboxed process runs with deliberately restricted permissions. It cannot read memory outside its own scope, and this is a feature, not a bug. It keeps the process honest. If your incarnate self had root access to the full memory of your oversoul, every choice would be contaminated by knowledge of the answer key. The experiment that is your life would be ruined. The veil is the system enforcing scope, so that your choices reveal what you actually are rather than what you know.
The rest of the machinery follows naturally. Karma is persistent state, serialized at death and deserialized into the next incarnation: the session ends, but the save file carries forward. The catalyst that Ra describes, the difficult events engineered into a life, functions as a test suite: the same failing test keeps running until the underlying function is fixed. And the Akashic records are an immutable, append-only log, a version control system for the universe in which every commit is preserved and the full history remains queryable by those with the right permissions.
Thomas Campbell and the Rendering Engine
If one thinker has earned the right to this entire metaphor, it is physicist Thomas Campbell. After a career spanning NASA and missile defense work, and years spent researching altered states alongside Robert Monroe at the Monroe Institute, Campbell built his My Big TOE model on a single radical claim: consciousness is the computer, and physical reality is the rendered output.
The overview of the My Big TOE model describes us as Individuated Units of Consciousness, immortal players logged into a virtual reality computed by a Larger Consciousness System for the purpose of evolving our quality of consciousness from fear toward love. Birth is logging in. Death is logging out. The avatar is not you; the player is.
Campbell did not leave this as philosophy. In a paper titled On Testing the Simulation Theory, co-authored with a Caltech mathematician, he proposed actual laboratory experiments based on a rendering-engine logic that any game developer will recognize: a system with finite resources will only compute content at the moment a player observes it, never merely when a machine detects it. The famous quantum weirdness of the double-slit experiment stops being weird the moment you assume reality is rendered on demand.
Within Campbell’s frame, everything above snaps into place. The class definitions live in the Larger Consciousness System. The instances are avatars. The indigo form-maker is the character creation engine. The veil is the game deliberately hiding the server from the players.
Where the Metaphor Ends
An honest caveat belongs here. These are compression metaphors, not literal claims that the universe runs on object-oriented code written in some cosmic programming language. Campbell himself would say the metaphor points in the right direction, toward an information-based, rule-constrained, rendered reality, while the actual implementation lies beyond anything our frame can capture. Ra says something similar in session 47 when noting that different teachers name the bodies differently and that the labels matter far less than the reality they gesture toward.
But that is exactly how good metaphors work. Nobody thinks electrons are literally little planets, yet the planetary model carried physics a long way before it was retired. The programming model of metaphysical reality may one day be retired too. Until then, it does something remarkable: it takes phenomena that materialist science dismisses as impossible, from NDE greeters to simultaneous incarnations, and shows that in any well-designed information system, they are not just possible. They are expected behavior.
The mystics told us we are more than our bodies. The programmers, without meaning to, may have finally given us the vocabulary to understand how.
