ANDERS MAGE PAGE 2.0

Based on ideas presented in Paul Beakley's Paradigm Page and John Walter Biles' VA Tradition Tome.

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.

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.

The 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.

The Spheres

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 coordinates 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 Magick — 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. All arrays are written in Code (Prime), so all arrays must be created by the Programmer by writing the Code for the array and then 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. 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 analyzes 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 (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 (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 rewriting 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 (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 neighbors. 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 have 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 a 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 Net gods 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 — Quintessence pools). These can be accessed and downloaded into arrays.

Foci

This part is house rules. Take them as you will.

Using Foci: Virtual Adepts themselves exclusively use computers to influence the Program (an extension of the old "as above, so below" adage). In the case of Reality Hackers, Prime and Spirit do not require a Network but a Net connection is useful (-1 difficulty?).

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. I thought it was pointless to have electricity as a focus for Forces. Most uses of Forces involve electricity to start with, so if you have some already as a Focus there's not much point to me in creating any!