by Constantine Thomas

Overview: Reality can be viewed as a giant Operating System, which contains many Programs that each represent a level of perception or existence. Most humans operate only within the Program - Awakened individuals (Programmers) have learned to actively change the Program from within. Physical Reality itself (known as the 'Interface') is the output of the Program as it runs. Programmers can change the Data within the Program itself to produce changes in the Interface.
     What we perceive as physical objects are actually Data Arrays. Once you learn to Reprogram a particular type of Array, you can alter the data in it, allowing you to change an object's motion, physical state, composition, etc. Reprogramming is best done on a computer - they are a great help in modelling the necessary changes for you. To move yourself or an object, you simply change its location in the Interface by move the data to a different location in the Program. By changing the programming language, you can move objects between the spirit and physical world, and so forth. By writing new sections of code, virtual realities can be created by changing their data contents and then finding a way to enable people to access this level of the universal Matrix.
     Each reality has its own Program, written in its own unique language. This makes up the rules of that reality. The minds of its inhabitants are constantly rewriting the Program, though the Technocracy is presently making low-level programming changes which are being retained and incorporated into the Program itself. It is possible to bypass the program and mess with the operating system itself, but among the Technocracy's program changes was the inclusion of a Debugging routine [Paradox] designed to prevent this. Physical reality has very effective Debug routines, but they can be kept at bay by deviating from the Program's approved operations as subtly as possible. By masking your action as an approved one, it is possible to evade the attention of Debug routines for long periods of time. One of our goals is to completely rewrite the Program of physical reality, and ultimately revamp the complete operating system. This will require the co-operation of the sleepers.

Paradigm: The Program. There are many Programs [Realms], each running within a single huge Operating System [The Metaverse] - the Earth is one such Program. The Near Umbra and the Realms within are different Programs written in the same language as our own, while the Other Realms of the Deep Umbra are written in completely different Code. The Physical Reality experienced within each Program by its inhabitants is created as the Program runs.

Magick: Reprogramming. Adepts know how the operating system works, and can use their skills to reprogram parts of Reality's code. Reprogramming is carried out in the Runtime of the Program.

Mages: Programmers. Those capable of Reprogramming are (not surprisingly) known as Programmers.

Awakening: Upgrading Priority. Upgrading your Priority within the Program allows you to become a Programmer - Sleepers have lower Priority than Programmers.


Correspondence: Space in Physical Reality is merely the environment created as a Program is running - this is known to programmers as the Interface. Everything has a location (denoted by a set of four-dimensional co-ordinates within the Interface, indicating its current spatial location and the present Runtime). Programmers can alter the location and spatial parameters of objects in the Interface by directly changing the appropriate part of the Program that governs the location of the Array in the Interface. Some less-enlightened Programmers refer to this reprogramming as 'shifting through the Correspondence Point'. By rewriting the relation between the Program and the Interface, Programmers can create multiple copies of an object in the Interface, or can perceive distant locations by scanning the Program.

Entropy: Self-Diagnosis. The Operating System itself has several self-diagnosis and self-modifying algorithms built into it. Old and obsolete pieces of code are replaced by newer, more efficient ones, which themselves eventually become out-of-date and are replaced. This constantly causes the Program to evolve and upgrade itself. Programmers can encourage this and so cause Arrays to decay and devolve so they can be replaced by new ones.

(Chaos: Randomness. One of the Program's natural self-modifying algorithms governs probability. Random self-modification is one of the most important ways in which the Program can evolve. Randomness occurs within limits set by the Program, though Programmers can vary these limits to make events more or less likely on their own terms.)

Pattern Magicks: Data Arrays. All physical Patterns are Data Arrays within the Program. By Reprogramming the data in these Arrays, the Programmer can change the Array's output in the Program as it runs. Arrays are written in Code [Prime], so all Arrays are created by the Programmer by writing the Code for the Array and programming in the Data.

     Forces: Forces are one of the three primary Data Array types of the Program. They are the most dynamic data type. Their array of data is constantly in flux. By altering components of these arrays, energy can be summoned, channelled or removed. However, to create new energy Arrays, knowledge of Prime is necessary to channel the quintessence to create a new data array. Access to a source of electricity can provide a good template for building new Force Arrays, while use of a computer is vital to model the data flow.

     Life: Life data arrays are the second of the primary Data Array types of the Program. They are the second most dynamic data type. By manipulating the data stored in the array, the properties of a life form can be altered and by scanning their array, many things can be learned about the lifeform.

     Matter: Matter data arrays are the third and least dynamic of the primary data array types of the Program. As with the other primary Arrays, the properties of matter can be manipulated by changing the data within the Array. The use of a computer can facilitate analysis and alteration of a matter data array.

Mind: Self-Modification Subroutines. Subroutines are associated with Life Arrays, which are used to carry them around the Interface. In Physical Reality, the mind of any creature is often itself considered a very special kind of computer, capable of thought, emotion, and opinion. Within the Program, however, a Mind exists within the Program as an independent Subroutine containing a unique closed Data Array, whose data is not normally accessible to outsiders. Essentially, they are isolated systems that exist as sentient, independent, intelligent units in the Interface.
     Subroutines are an essential part of the Program's self-modification algorithm - they actively change the Program, through direct interaction with the Interface. They do this in Runtime via the senses (I/O devices), which send data from the Interface to the Subroutine's closed Array. The Subroutine itself analyses the input and disseminates any necessary changes to the Program. However, a Programmer can access the Subroutine and so alter the contents of the Data Array within, or even the Subroutine itself. Computer modelling of the targeted mind can facilitate proper modification or analysis of the target. Most Subroutines have fairly low Priority [ie. Sleepers] - while individually their suggested alterations take time to implement, cumulatively they provide the foundations on which the Program is written. Programmers have higher Priority within the Program, and so can make changes where they see fit - however, their alterations are subject to Debugging if they prove so drastic as to compromise the integrity of the Program.
     The more complex the Subroutine, the more difficult it is to access and alter. The effect known as 'Astral Projection' or 'Untethering' actually disconnects the Subroutine from the physical data set (ie. Life Array) that it is normally associated with, creating a 'Virtual Data Array' that can carry the Subroutine through the Interface. These 'Virtual bodies' can interact with each other, but can ignore the physical limitations of the Interface. The Virtual Array remains linked to the physical body, and severing this link can have grave consequences.

Prime: Code. Code is the actual language of the Program itself. By re-writing the Code of the Program, a Programmer can directly affect Data Arrays, as opposed to the Data within them, and so have great control over Physical Reality. This can range from altering the parameters of an Array to allow it to hold more Data [Quintessence], creating new Arrays (ie. Patterns), removing Data from an Array to remove some of its Physical properties, or transferring Data from one part of the Program to another.

Spirit: Other Programs. Other Programs also exist, containing their own Arrays and Subroutines. There are Programs written in the same language as our own, known by most Programmers as the 'Near Umbral Realms' or the Near Programs, while others - the 'Deep Umbral Realms' or Deep Programs - are written in completely different languages. All Programs can be accessed or observed by adapting the parameters of one's Subroutine and Array so that it fits within the destination Program. The difficulty in adapting parts of one Program to another manifests as 'the Gauntlet', a subjective barrier between individual Programs that serves to prevent easy access and contamination of the Code of one Program by another. However, access is much easier between those parts of the Near Programs that have similar sections of Code (eg. Garou Caerns, Nodes). A much stronger subjective barrier (the 'Horizon') exists when attempting to access Deep Programs, since the Code of these Programs is written in a completely different language to our own and that of our Near neighbours.
     In addition, the Net is fast becoming a Program in its own right embedded within our own. Certainly, it contains its own unique Arrays and Subroutines, though fortunately no 'Gauntlet' exists since we are defining its Code ourselves.
     Other Programs are best accessed via a Virtual Reality Network, though any Network will suffice.

Time: Processing Time/Runtime. All Programs are running, which creates the Physical Reality (the Interface) experienced by the Data Arrays and Subroutines of the Program itself - effectively, the Program is creating its own Virtual Reality environment in which to run.
     The Interface runs according to the Operating System's Processing Speed. This manifests in the Interface as elapsed time, though Programmers refer to this as Runtime. Programmers can be aware of the precise Runtime and can even examine the Program Code and extrapolate events forwards or backwards within the Runtime, thus becoming aware of events that have happened or will occur in the Interface. More experienced Programmers set up routines that can change the effective Processing Speed of the Operating System within part of the Interface, thus making the Program elapse faster or slower, and can even temporarily Pause the Program. The most advanced Programmers can edit the Program itself and take Arrays and Subroutines out of one part and re-insert it so it appears later in the Runtime. However, no means has been found of retro-editing the Program and inserting Arrays into parts of the Program that have already Run.


Arete: Eliteness: Eliteness is both a specific Virtual Adept classification and an more generic one. Generally, Eliteness represents the extent that the Program is understood, which indicates how well the Programmer can alter the Program. To the VAs, Eliteness is everything - it is how you separate the losers and posers from the real netheads. Those with high Eliteness are respected as the coolest, most daring, bad-ass NetGods around...

Ascension: Uploading. The ultimate goal of Programmers is to understand the Program so well that they can upload themselves into it and become part of the Program itself.

Quintessence: Data: Quintessence is the Data that fills the Arrays. While each Array has a specific configuration of Data within it that separates it from other Arrays of the same type that can itself be altered, the Data itself can be manipulated, added to, transferred between Arrays and even removed.
     The pools of Raw and Free Quintessence arise as a result of Virtual Data - Data which is not currently assigned to an Array. Virtual Data can be uploaded into Arrays and made Real.

Paradox: Debugging. If Programmers make alterations to the Program or the Code itself that are outside acceptable parameters, Errors can accumulate in their Subroutines [Paradox Flaws]. If the Errors become too large, the Debugging routines [Paradox Spirits] of the Program home in on the Flawed Subroutine and Debug it [Paradox Backlash]. Occasionally, the Subroutine is so Flawed that it must be removed from the main Program and placed within its own Sub-Program/Interface in order to be corrected without disrupting the rest of the Program [Paradox Realms].

Mage-specific Backgrounds

Arcane: Hidden Files. Some subroutines are Hidden within the Program, making them in turn less noticeable in the Interface.

Avatar: Priority. Subroutines with high Priority can affect the Program around them, while those with low Priority can only act within the Program. One's Priority also indicates the amount of room set aside within their Subroutines to store Data.

Destiny: Output. Some Subroutines are written to perform specific tasks within the Program. Output from these Subroutines often has great effect on the Program around them.

Dream: Program Analysis. Programmers can examine parts of the Program that have already elapsed and retrieve information from other Arrays and Subroutines.

Node: Data Dumps. Some parts of the Program act as dumps for Real Data (as opposed to Virtual Data [the Quintessence Pools]) - these can be accessed and downloaded into Arrays.

Using Foci: Virtual Adepts themselves exclusively use computers to influence the Program (an extension of the old 'as above, so below' adage) - NO OTHER FOCI ARE REQUIRED FOR THE SPHERES. Indeed, the VA Paradigm is unusual in that the way it views Reality is mirrored in the way that Reality can be changed - it is difficult to see which came first. Whether Reality was considered as an Operating System before the invention of the computer and their smaller operating systems, or whether the invention of the computer itself created the paradigm has yet to be determined. Essentially, Adepts use a variant of the Hermetic Law of Sympathy - by using programs on their computers they can mirror the Program that is Reality.

Back to the Old World of Darkness Hub
FrameSet URL: