All of this website talks about it, but it's never really explained. What IS Systemspace? In short, Systemspace is a collection of realities called Systems.
Systemspace, in and of itself, is just a gigantic pool of Aurora. A System then shapes the Aurora however it wishes to create life, death, mountains, oceans, planets, space, its own perception of time and everything else.
Imagine a perfect empty System. It currently uses 0 hA (hA being a unit of measurement for Aurora). Now let's say we add a cube. A simple, plain white cube, that costs 100 hA. The System draws the necessary 100 hA from the pool (Systemspace), and uses it to create the cube. Destroy the cube, and the Aurora is freed back into the pool. In this example, Aurora is like RAM or disk space in a computer.
However, Aurora has a second function, and that is to spark activity. Aurora can think, to the point where its sentience is debatable. As such, Aurora is used for many things where "randomness" (or rather, a choice from outside) is needed, like creating universes or souls. Lastly, Aurora also governs the actions that are taken, by influencing the possible timelines and picking from them.
But how do you just "add a cube"?
Actually, it's quite simple. You simply force it into existence. In fact, all existence is based around force - or rather, rules. Such rules, called Axioms, are the main way to implement Aurora into specific objects. For example, to create a cube, we can simply define an Axiom such as "There is 100hA allocated to a cube". Of course, this Axiom is far too vague, and as such Aurora will take the lead and "do as expected": create a simple solid, averagely sized white cube of a plain texture in the middle (well, there is no middle) of the System.
These Axioms are expanded further and further upon as you develop a System - and for this reason, Axioms are almost never written by hand. There's special software and programming languages (so to say) that create Axioms and much, much more.
But Axioms only define what exists, not much about what it does. And never are these Axioms communicated with the User. This is what Promises are for.
Okay, I think this is best to just demonstrate. Below are 4 links, try hovering over and pressing them. See what happens!
As you can tell, only 2 of these links make sense. The first doesn't look and feel like a link, and the last feels like a link and is one. These fulfill the Promise that they send you. The first two links send the Promise to be normal text, and not do anything when clicked on. It feels weird when the second bit of text is clickable, because it exceeds its Promise. The last two links send the Promise to do something when clicked on, and although the last link handles it fine, the first link does nothing. Again, the Promise is broken, because it doesn't do anything. In fact, you might even have clicked it twice just to make sure your browser wasn't acting up. (Have you?)
This is the basis of Promises - telling the User their possible actions. This is how the User knows what they can do, without wasting any time and resources rendering and parsing any senses, which we'll get on to later.
Not only Users use these though, these are also used within Systems and towards Aurora. They form the basis of actions - what the User or another element of the System can do.
When a Promise is agreed upon, the Method is called. Simply said, when you decide to click the link, you are sent to another page. For a System, this is most of the System's code. For example, the System promises (as your body) that your right leg will move up when you send a signal to. When you agree upon this Promise, and send the signal, the leg moves up. Or rather, the Axioms are changed to move your leg to a new position.
When your leg moves up, you need to be alerted of it, otherwise the Promise would fail. And when you open your eyes, you need to actually see things, or else the eye's Promise would fail. Not only that, but Systems also tend to be more enjoyable when you can, you know, experience them. For this reason, there are a plethora of senses that Systems can implement, add or expand upon. Senses are quite simple, for example visual senses are usually just data sent from the System to your brain (if any), to the Soul. The brain or Soul converts the image data to objects and Promises, and sends those to the Soul, which asks the User to make a choice, evaluates that choice, then executes it.
Senses don't have to be visual, they can be anything - humans mostly know their eyes, ears, nose, touch, etc... but there are many more, even just in Life. But a System creator can be very free in this! They can add any sense they want, and implement it how they wish, as long as the User gets data it can parse in the end. Of course, if you want to be even somewhat supported, you'll need to have your Souls comply with the standards, too.
I can already hear you think "ah, finally" as this term is finally expanded upon. Souls are probably the most interesting part of Systems. They are what connect you (the User and Experience) to the System and its worlds within. But how do they work?
Well, that mostly changes per System. However, there are some standards that should be used if you want compatibility with other Systems, which although not yet required, will be in the near future. Souls are mostly quite simple though. They hold memories, your personality, and everything else that makes you "you". They allow the User (the most raw version of "you") to connect to a System. They are Auroraic (made from Aurora) structures, but do not follow every rule related to Aurora, as they are controlled not by Aurora or Axioms, but by the Users.
When a System creates or receives a Soul, they will get a body for it that it can use. Usually, a new body is born in time, however, if none are available, the System may be slowed down or sped up until there is a new body available. Or, if the System owner has arranged it so, you may just inherit a body that belonged to AI (or rather, Aurora). Then, you get all the Promises and senses for that body, and can do whatever you want in the System, now being able to sense the surroundings, know your options, use them, and sense the result.
All Systemspace does is provide the massive amounts of Aurora required to keep Systems running. It's like a big hosting provider! Making a System is rather easy too! You just get a certificate for the size of System you need (the less you need, the easier it'll be to get one), and begin coding! Or, if you don't want to build a System from scratch, you can use open-source frameworks like LFX (by SYNAPSE, which is also what LFE (also SYNAPSE) is built upon).
Furthermore, Systemspace hosts a set of preinstalled tools which allow you to traverse the Systems with ease.
Good question. You are in the System called Life. Life is a "closed" System, which means it blocks a lot of inward and outward data. For example, you can't take memories or Souls into our out of Life. Life is meant to be a rather simple System, with just 1 universe, inhabited by only 1 soulful species.
However, Life is not... ......programmed that well. In fact, its programming is horrible. It uses a LOT of Aurora. Therefore, it needs to be shut down. Usually the Ghendyts does this (see more about them on the page of KAHGY) quite swiftly, but that has proven to be a failure. Life keeps incarnating itself, so it needs harsher measures. Simply said, it will be unlinked, causing it to free all Aurora and not be able to return. The System will continue on in a sort of "zombie" state, using fake Aurora it generates for itself... but it will soon after end.
Therefore, you are given this option to leave! I hope you will take (or have taken) it!
Use all animations
Always show marquee