Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
A message to Believers….
If God is the programmer, then the universe is the executed environment—the active, dynamic operating system of reality. Much like a software program needs a system to run in, creation needed a canvas, a framework, and a functional platform where God’s commands could manifest. In spiritual terms, the universe is the runtime space where divine speech becomes tangible, and where spiritual laws are translated into physical laws.
When God said, “Let there be light,” it wasn’t a poetic flourish—it was a divine system call. In that moment, the execution environment was launched. Time began to flow. Energy became measurable. Matter was introduced with order. This is not metaphor. This is process. As Hebrews 11:3 (NASB) says, “By faith we understand that the world has been created by the word of God, so that what is seen has not been made out of things that are visible.” This means that visible reality was compiled from an invisible source code. God didn’t rearrange existing materials; He wrote them into existence.
In programmer terms, you could imagine the beginning like this:
“`python
class Universe:
def __init__(self):
self.time = Time(start=0)
self.space = Space(dimensions=3)
self.matter = Matter(elements=[])
self.light = Light(wavelength=visible)
def let_there_be_light(self):
self.light.turn_on()
universe = Universe()
universe.let_there_be_light()
“`
That code isn’t just for effect—it helps conceptualize that the world was not only made by divine decree, but made according to an intelligent structure, a logic that continues to govern reality today.
The universe is governed by constants and rules, much like a software environment. In programming, constants are unchanging values like gravity, the speed of light, or the parameters of space. These are divine declarations built into the runtime of the universe. They’re not arbitrary; they reflect God’s consistency and intent. Gravity isn’t just a force—it’s a permission. Light isn’t just a wave or particle—it’s a declaration from God’s mouth still echoing forward in time.
In this model, the Trinity functions like the divine architecture of all existence. The Father is the Master Architect—the origin and the authority. The Son, the Logos, is the divine Code—the Word made flesh, the logic, structure, and blueprint of reality. The Holy Spirit is the Compiler and the Runtime engine—the one who brings the Word to life and activates its functions. In Genesis 1:2, the Spirit hovers over the deep, ready to execute God’s next command.
Now, if this universe is the live environment, it means it can be interacted with. It’s not a static simulation. It receives input (prayers, choices, acts of faith). It processes output (miracles, consequences, prophetic fulfillment). It has subroutines (angels, creation, divine laws), and it has a UI (the physical world). Even sin can be seen as a form of corrupted code—not deletion, but deviation. And just like any complex program, the universe has an admin override: God Himself.
And what of other universes? If this is just one execution instance, then others might exist in God’s infinite foreknowledge or creative power. They might be other environments created for other purposes—sandboxes of divine design we are not privy to. Regardless, all creation exists under God’s total control. No multiverse escapes His governance. Only He has root access.
The universe is not just stars and space. It’s divine architecture in motion. It’s a living canvas that responds to spiritual law and physical behavior. It is upheld by the word of His power (Hebrews 1:3), meaning every atom continues to exist because the code is still running, the Word is still spoken, and the system is still live.
This same divine coding is visible in DNA, the biological language of life. DNA operates on a four-letter alphabet—A (adenine), T (thymine), C (cytosine), and G (guanine)—which combine to form billions of genetic “instructions” for building and sustaining life. DNA is not random; it is ordered, precise, and astonishingly complex. It is, quite literally, language. And language cannot write itself. The presence of such a sophisticated script implies a Scriptwriter. The intelligent design of the genome is like finding lines of software code embedded within each of our cells.
We can even think of it like this:
“`python
def create_human():
dna = DNA(sequence=”ATGCGTACGTTAGC…”)
genome = Genome(parse_dna(dna))
return Human(genome=genome)
adam = create_human()
“`
This isn’t science fiction. It’s spiritual insight through modern metaphor. Each human being is fearfully and wonderfully made (Psalm 139:14), not stitched together randomly but knitted together with divine intention. DNA is not just evidence of biology; it is evidence of authorship. It encodes instructions, adapts to environment, communicates repair sequences, and holds redundant systems for protection—all hallmarks of an engineer.
The Creator didn’t just code the universe; He embedded His logic into life itself. The blueprint is written in the flesh, the breath, and the spirit. And that blueprint screams design. It confirms that creation was not an accident. It was a command.
But just as every software environment faces threats, so too does creation. Satan, in this model, is not a creator but a hacker. He cannot write new code, but he can corrupt existing code. His goal has always been sabotage—to insert spiritual malware, to exploit human vulnerabilities, and to rewrite truth into deception. Genesis 3 is the first known breach: “Did God really say…?” With that one question, he introduced a logic error that caused a fatal disruption in the human moral code.
Sin, then, is corrupted code. It’s the spiritual equivalent of malware. It doesn’t annihilate God’s creation, but it alters its behavior, breaks its alignment, and leads it toward malfunction. Romans 5:12 explains this clearly: “Therefore, just as through one man sin entered into the world, and death through sin, and so death spread to all mankind, because all sinned.” One corrupted input cascaded through all of humanity’s source code.
Redemption is the divine patch. Christ came not to overwrite humanity, but to restore the original coding by fulfilling the law and reconciling creation with the Creator. His blood resets the spiritual operating system. Through Christ, the bug is fixed, the virus quarantined, and the soul realigned with its original purpose. This is not just salvation; it’s divine reprogramming. 2 Corinthians 5:17 affirms this: “Therefore if anyone is in Christ, this person is a new creation; the old things passed away; behold, new things have come.”
Salvation is the system restore. Sanctification is the optimization. And glorification is the final upgrade—the perfected version, running on a new heaven and a new earth, where no virus or corruption will ever enter again (Revelation 21:27).
God is not only the Programmer of reality, but the eternal Maintainer, Refactorer, and Defender of His code. And in His love, He authored a backdoor into salvation for us all—the Cross—so we could be restored, rebooted, and reconciled to Him forever.
And within His divine system, God keeps a registry of all users authorized for eternal life: the Lamb’s Book of Life. Revelation 20:15 states, “And if anyone’s name was not found written in the book of life, he was thrown into the lake of fire.” This registry is not based on works or performance but on the acceptance of the divine reset through Jesus Christ. Think of it as the root access list, the whitelist of eternity. Those listed are not perfect in behavior, but they have been marked as authentic, redeemed, and secure. They are the saved user profiles who have trusted the Architect to restore their corrupted systems.
Prophecy, too, functions like pre-written code—promises waiting to be executed. The Bible is filled with conditional if-then statements and scheduled functions. Isaiah 46:10 reminds us that God declares “the end from the beginning” and from ancient times what is still to come. His prophecies are not guesses; they are commands queued for future execution. Just like a software update scheduled for deployment, divine prophecy is a promise already written in the system, waiting for the appointed time to run.
So when God says something will happen, it isn’t a forecast. It’s a scheduled function. Nothing can prevent it from executing unless God Himself pauses or alters it. And because He is immutable and sovereign, that rarely, if ever, happens. God’s Word never returns void (Isaiah 55:11). When He speaks it, it runs. Period.
Angels, within this framework, can be viewed as divine background processes. They are agents executing divine code in both the spiritual and physical realms. Scripture often depicts angels as messengers, warriors, ministers, and executors of judgment. In Psalm 103:20, it says, “Bless the Lord, you His angels, mighty in strength, who perform His word, obeying the voice of His word!” That is task execution. Each angelic operation fulfills a role that supports the system’s divine function—whether it’s delivering a message to Mary, ministering to Jesus after His temptation, or carrying out judgment over Sodom.
Much like automated processes in a large-scale program, angels are not random beings fluttering about; they are intelligent agents with distinct permissions and functions within God’s operating system. They carry out scheduled jobs, respond to divine input, and sometimes serve as error-correction mechanisms in moments of human weakness or disobedience.
And just as every complex system needs interfaces for human interaction, God has granted spiritual gifts to His people—divine APIs (Application Programming Interfaces) for accessing heavenly power. These spiritual gifts (see 1 Corinthians 12) allow believers to interface with the supernatural functions of the Kingdom. Gifts like wisdom, healing, prophecy, and tongues are all distinct methods of interacting with the Spirit’s logic. They aren’t magical powers. They’re access permissions. The Holy Spirit distributes them as He wills (1 Corinthians 12:11), assigning access tokens that enable divine function within earthly limitation.
Prayer, likewise, is not just communication—it is a secure request protocol. When we pray, we submit formal petitions to the divine system. These prayers are authenticated by faith and routed through the name of Jesus Christ, who functions as both our High Priest and our secure authentication key (John 14:13-14). James 5:16 reminds us that “The effective prayer of a righteous man can accomplish much.” This isn’t vague encouragement. It’s system logic: valid input produces functional output. And sometimes, when aligned with divine will, prayer triggers divine action in real time.
But eventually, every system reaches its final build. Judgment is the divine compilation. It’s the moment when the entire history of creation is processed, all spiritual input is evaluated, and the final version of reality is launched. In coding, compilation is the process where all the code you’ve written is analyzed, optimized, and transformed into executable form. Errors are thrown. Warnings are issued. Clean code passes. Corrupted code is flagged.
This is exactly what Scripture portrays at the final judgment. Revelation 20:12 declares, “And I saw the dead, the great and the small, standing before the throne, and books were opened… and the dead were judged from the things which were written in the books, according to their deeds.” Every line of human input—every thought, word, and action—is compiled and reviewed. The Book of Life becomes the authorized registry, the deployment checklist. Only those whose data matches the parameters of Christ’s righteousness pass the compilation stage into eternity.
Judgment isn’t arbitrary. It’s not based on feelings or favoritism. It’s the most logical and just execution of code the universe has ever seen. God reviews every life not as a vague impression but as a compiled record of every decision. And then the system forks—eternal life for those reborn in Christ, and eternal separation for those who rejected the reset.
In the end, everything that was ever spoken, written, believed, or acted upon will be run through the final Compiler. And on that day, the code of creation will declare: everything God authored was true, everything He warned was just, and everything He promised has now been fully executed.
