You’re out there
My shimmering pulsar with a ray

Distant, interstellar, somewhere
Your beam is light years away

A shining beacon, a lonely flare
Dispelling coldness on the way

I will travel, and I will chase
To look again upon your face
A homing missile, through outer space
Seeking, reaching, for your embrace

You’re out there
My shimmering pulsar with a ray

Distant, interstellar, a blinding glare
Your beam will guide me, one fateful day

I’ll journey to your orbit, and I’ll be there
I’ll hold you, and keep the coldness at bay

I will travel, and I will chase
To look again upon your face
A homing missile, through outer space
Seeking, reaching, for your embrace

You’re out there
My shimmering pulsar with a ray

Distant, interstellar, a sight so rare
A visage so beautiful, it bends light astray

Burn ever brighter, ’cause for you I’ll dare
to challenge the fates, and come what may

I will travel, and I will chase
To look again upon your face
A homing missile, through outer space
Seeking, reaching, for your embrace

“Distant Dreams – My Pulsar (Radio Edit) – June 2116”[1]

Morning, Day 5 AoE

Adiah sat across from Ethan in the crowded university cafeteria. She twiddled her spoon idly as they shared a communal breakfast that morning. She suddenly smirked mischievously, and asked him a strange question out of the blue, “What does the zombie physicist eat?”

“What?” Ethan asked in bewilderment. He’d honestly thought he’d heard her question incorrectly, given the loud and crowded setting.

“Branes[2]! You doofus!” she said before giggling loudly.

“Oh god! You colossal nerd!” Ethan accused after a hearty laugh that left him breathless.

Many heads turned to look at them in disdain, but he no longer cared about their dirty looks or opinions. He was truly happy for the first time in forever, and they could go to hell if they thought their looks could change that. He no longer needed their approval.

A chime sounded and broke him from the pleasant memory. He didn’t want to wake up, but he knew he had to.

Ethan abandoned his dream and woke up to an urgent notification from his AI, his groggy eyes glazing over as he looked at the messages.

His AI had just issued a high priority alert as instructed, because one of its priority tasks had been completed.

Ethan stood up slowly, stretched, and kicked away an incomplete husk of another failed prototype. He went to sit at a nearby stone stool as his stupor fully abandoned him.

He was finally free from having to patch primordial spells together. He was finally free from having to design his spells using the primitive pseudo-formula syntax he’d initially come up with. One which he – quite frankly – found woefully lacking. If only because he had to consider the structure of the spell model whilst also working on the underlying logic. It was an inefficient process; because he couldn’t use discrete units of measurement, and could only build the spell with the stronger thaums having more ‘weight’ to them in the relative distribution of the spell’s mana.

He contemplated his recent breakthrough into the nature of magic on the first days of his voluntary isolation. It had had a great outcome, to be frank.

Finally free of the daily distractions, the influence of emotional-suppression drugs, and thinking like himself again for the first time in a long time, he’d contemplated this property of spell models, and managed to unlock one of the secrets behind thaums: other than their type – which determined the rules of connectivity between them and the kind of reaction caused by Mana meeting with Conduit particles whilst imprinted by a specific instruction – every thaum had another adjustable property he’d so far mistook to be structural, or size-related; but empirical evidence through experimentation proved that assumption wrong.

He decided to dub this property ‘intensity’, and it governed how strong the reaction from Conduit particles to a Mana particle was. A thaum configured with a higher intensity would require more mana to activate, and would cause a stronger effect to manifest, in relation to the average baseline of other thaumic instructions. The only way Ethan could describe intensity was as a ‘memetic charge’ of sorts, but that was a stupid name, so he gave it a more apt name that applied only after Mana was imprinted by a thaum: the thaumostatic charge.

Ethan finally understood the true purpose and peculiarity of Mana as a subatomic particle: it was a carrier of information, not just energy.

He decided to assign the baseline minimum of thaumostatic charge to result from activating the simplest thaum in its neutral state – the structural one he called Connect – the relative value of 1 Thuum, with every full multiplier of intensity giving another increment of 1.0 Thuum.

In essence: a thaum with an intensity of 3.0 Thuum would imprint mana with triple the effect, and charge it with 3 Th – with Th being his preferred shorthand notation for this unit.

With this new discovery, his old formula syntax was utterly obsolete.

Luckily though, that was the missing major discovery he had needed to push another project to completion, his AI had just notified him that it had finished building the binaries, and so he began to review the finished project in earnest.

A traditional computer architecture always had well-defined rules and parameters to conform to. For centuries, every manufacturer of integrated circuits – from CPUs to GPUs, to ASICs and beyond – would release datasheets containing the discrete parameters for the hardware, which described everything in great detail: from comprehensive lists of every instruction the system supported and the rules governing them, to register layouts, interrupts and signals, memory addressing modes, and so on and so forth.

The point was this: to write a toolchain targeting a specific architecture, one had to be aware of every nuance involved.

So, Ethan had ordered a huge modification to an old open-source compiler toolchain, to produce spell models instead of traditional programs.

The old compiler – in essence – was designed for a high-level Domain-Specific Language[3] based on an obscure software design pattern for state machines. He’d tasked his AI with repurposing this old open-source compiler quite a while ago, soon after he’d discovered thaums and their properties, then forgot all about it while letting it run the absurdly difficult task in the background.

While all computer architectures had to be well-defined in advance to be a viable compilation target, this world’s magic was not. Which presented a challenge, because Ethan had very limited knowledge to work with. He’d established most of the basic rules, and collated enough data to develop basic spells, but he had no way of knowing what other thaums remained out of his reach, and he did not want to keep editing and re-compiling his new magical compiler every time he discovered a new thaum. Not to mention the new discovery of Thuums, or the unit tests… those would take ages to update and rerun every single time he added a new thaum.

In the past couple of days he’d actively pushed the project forward. No longer satisfied by being a passive observer and letting his AI do all the work, Ethan had resolved himself to no longer let things happen around him, and to no longer react only when he had to. He’d get his hands dirty and actively work his way out of this predicament. By hook or by crook, he’d achieve his goal of going back home.

And so he’d spent every waking moment during the last 3 days experiencing accelerated time inside his simulated virtual lab. Weeks of time had passed for him, and with the exception of taking care of his physical needs, he worked and collaborated with his AI to rewrite large swaths of code. He spent the times in-between – during long compilations or computations he could not help with – designing a viable chassis for an advanced magical drone.

The reason it had taken so long for him and the AI to finish this compiler was that it was made of more than a tokenizer, a lexer, a parser, and an emitter. Unlike other compilers, it also had to account for a specialised module and a custom emitter he’d created, and those needed to be integrated into the pre-existing codebase.

His idea was to internally utilise something called an Incremental Tensor Graph to grant this compiler the ability to learn and integrate new thaums into itself. This way, it would be able to improve and adapt itself to an ever-expanding architecture. It was many a step above the simple Generative Adversarial Network he’d used in The Divine Sceptre of Primordial Will.

At this thought, Ethan decided he was done with the theory. He itched to try out his new compiler.

He looked at his AI’s improvised IDE[4], and found that it was adequate for his purposes. It was a code editor he’d specifically commissioned for his use along with the finished project.

It was time to code something again, and for the first time in weeks: Ethan’s face lit up with a genuine smile.

[Commander] Talius roamed all over the Krell settlement in spirit form, and observed in wonder.

His tether to Ethan West did not restrict his movement much, and although he felt he was being parasitic in a way, he couldn’t turn down Ethan’s offer of a sustained mana donation.

His existence was too boring otherwise, and that man did him a kindness Talius doubted he knew the magnitude of, because no matter how small the amount, it was still enough to allow him to interact with the world again.

Even though Talius could manifest and communicate with people, should he so choose, he chose not to. He truly did not want to scare innocents – especially children – as they went about their daily lives.

That changed as he spotted a set of familiar female Polarii horns towering over the crowd and moving with a purposeful gait.

“Aylin? Aylin Merza?” he whispered, and as if sensing him, she paused, turned, and looked; but saw nothing out of the ordinary. She seemed to be lost in thought, but looked alive and well.

So Talius started following her around. His curiosity at how this came to be burning with unprecedented intensity.

Why was Aylin Merza amongst the Krell? And why was she still alive? Wasn’t this the same Aylin Merza who torched Krell villages with abandon like it was nothing?

Yet she seemed to coexist with them, and they… seemed to respect her?

Aylin paused in her walking as a small human child tugged at her robes. She looked down with a frown at the obstruction, and Talius felt himself subconsciously tugging on the mana tether, drawing more and more mana to his soul, despite his promise to himself never to do that.

Just before Talius manifested into a tangible cloud of spiritual energy to defend the child, Aylin noticed the source of the disruption and kneeled down. She touched the girl’s head and closed her eyes as if in prayer, and the child seemed to freeze.

Aylin lifted her hand, and Talius’ spirit vision could see the divine blessing’s energy twirling about the girl, its effects apparent on the child. The little girl smiled and ran off laughing.

Aylin stood and smiled grimly.

Did she just show kindness? Or was it a ruse?

Had Aylin become a [Priestess], then? But when? Why? And how?

Was she now a [Priestess] of the new Goddess of Science he’d heard about? But that would mean that Denvar would…

Too many questions needed answering; but before revealing his presence to her, Talius decided to follow her around and observe closely.

She navigated through the crowd with surety, and people nodded, acknowledging her. His eyes tried to wander and look at all of the wonders happening around him, but he had to stay with her, lest he lose her trail.

A half-finished golem made of a bronze-like material that seemed to be unnaturally flexible stood in a workshop to the side, its chest was wide open, exposing all the clockwork inside. A gnome woman was reaching into its open chest with a tool while talking enthusiastically to a [Blacksmith]. A dwarf was writing furiously in a journal to the side, whilst somehow simultaneously chugging impossible quantities of ale.

Talius ignored the spectacle. It was not the right time, and Aylin had disappeared around a corner. He quickly followed after her.

He saw the tail of her robes trailing behind her as she entered a building that was being renovated with new wooden supports. He phased through the room’s solid wooden walls, only to find her waiting for him expectantly.

“What do you want, spirit?” she asked him icily. Her gaze settling on him.

“You can see me?” [Commander] Talius wondered aloud, but it seemed she couldn’t hear him.

Sighing, he drew slightly on his mana tether and manifested.

“Who are you? And what do you want?” she asked while preparing a spell he assumed to be offensive in nature.

“Hello, Aylin.” Talius spoke.

Adrian stood stock still in the sunny glare of an open plateau, a cold stream of sweat running in rivulets down his back.

Still as a statue, his sword arm hurt from being held high. Heat from the sun cooked his body slowly; but he pushed on.

Soon after Ethan West disappeared into his workshop – to Adrian’s great dismay at never speaking to him – the ex-[Paladin] had realised that he’d now be hunted by the disciples of his old church for life, as an apostate.

And if that other life had taught him anything, it was that life was precious, and way too short. So he cast his lot. He told his old party that he was going to quit adventuring, and in the wake of their shocked expressions… he’d left and come to this quiet plateau. To train and prepare for what was to come.

He was wearing his old [Paladin’s] armour, and although the Krell elders had decided to give it back to him at the incessant prodding of Kothar, their [Champion] – which was an act Adrian still failed to completely understand – it felt… unfamiliar.

His fake life had felt more real than this one. He missed his [General’s] battle regalia.

He would wait, and he would meet with Ethan West, and ask him an important question that plagued his thoughts.

In the meantime, he trained, and prepared himself for what may come.

Ethan brought up one of his most complex primordial spells to date: the “Ambient Energy Collector” spell that he never quite managed to give a proper name.

This spell was his bread and butter, simply because it allowed him to absorb any hostile energy, as he had done in his most recent battle against the Eye, and against the beawick’s thralls later that same day.

Despite it usually afflicting him with the status [Overcharged – Mana] afterwards, it was still very useful. The fact that he used it as the basis for his Mana Cell proved that.

It was also a bit special in the way it utilised conditional thaums, which were usually reserved for use in enchantments by the denizens of this world.

As it were, it looked like this:

$energy = Detect() | Shape("Sphere") - 
    $(energy == 'Mana') { $energy } { Convert('Mana') * $energy } > Absorb

He created a new data node and attempted to reproduce this spell using the new syntax. In the process, he found himself unhappy with how it worked, and kept adding more basic features that should have been there since the start.

Ethan spent an indeterminate amount of time refining his spell, and working out the exact details, and before he knew it, it was ready.

It was comforting to relax and code something again, no matter how simple it was.

// Event-based recombinant programming! I thought they taught us this archaic crap 
// in college just to spite us, now I find it actually useful!

// The global variables below are part of the spell’s immutable state structure, 
// mutating the state in a `when` block will only reflect on the next state (remember 
// that, doofus!), and the spell will only advance by a single `tick` once all currently
// executing actions return. I’m only using constant variables here, so the state is 
// never updated.

/** Parameters: */

// Implicitly end the spell if no actions are fired during a tick.

// How many ticks per real second this spell will work at. Currently 1000, a tick is evaluated 
// once every millisecond.
// TODO: experiment with precision in a safe way later. A remotely-triggered enchantment?

/** Inputs: */

/** FIXME: Make all inputs adjustable after casting in the future? 
 *  Setting `@input` to 'once' makes it poll on startup only, while 'always' would poll for the input 
 *  with every new tick, or I could use a custom expression to determine tick times. 

// A control switch to decide whether or not to keep the user from overcharging by channelling to 
// the nearest detected object made of plastic. On by default.
const failsafe: boolean = true;

// Maximum spell duration in milliseconds, 0 disables the limit. (Default is 30 minutes)
const duration: number = 30 * 60 * 1000; // 1,800,000 ms

// Sphere radius in millimetres, defaults to 2 metres.
const radius: number = 2000;

 *  TODO:  Figure out how to handle the polling and information flow after a spell is cast?
 *  Possible solution: discover the information transmission thaums The Wheel is using 
 *  to bind to nervous systems of living creatures, and use those to send
 *  inputs to spells later. If The Wheel can use them, why can’t I?
 *  Alternative/bad solution: use encrypted digital transmissions over radio waves to encode
 *  the inputs in a future iteration, as a low-tech alternative? 
 *  Con: this could be bad for spell size and complexity!

/** State Variables */

// FIXME: Make the shape of the field adjustable in the future? 
// FIXME: The sphere’s radius won’t get updated if the radius is made adjustable in the future!
const sphere = new Volume.Sphere(radius);

 *  The following block is a condition/action pair. With every `tick` of the spell, it will 
 *  evaluate the condition enclosed in the parenthesis, and if it evaluates to true or a truthy value, 
 *  it will execute the enclosed logic defined by the action in a procedural manner.
 *  The `detect()` call can return `null` if it detects nothing, so we don’t really have to add an 
 *  extra `if` statement to check the variable again. It will skip the block when it detects nothing.
 *  Note: the keyword `with` can be used to restrict any spell effect to a boundary/volume, 
 *  and here we’re using it to restrict the field to a `Shape` based on the sphere we 
 *  instantiated earlier.
 *  Note: There are two variants of `detect` thaums: the first is for energy and the second for
 *  matter. They’re distinguished here by the standard library, the `Energy` namespace holds
 *  everything related to energy, including specific thaum variants, the `Material` namespace is
 *  for matter.
when(const energy = Energy.detect<any>() with Shape(sphere)) { 
  // The `as` keyword will cast the detected energy type to mana using the `Convert` thaum. 
  // Nothing will change if the original energy was mana.
  const converted = energy as Energy.Mana;
  // Note: `User` is a singleton instance that always refers to the caster of the spell.
  // I hate this syntax, but I had to encapsulate these contextual/structural thaums somehow. 
  // FIXME: Make this less ugly in the future: a.k.a. rewrite the thaumic standard library.
  if (!failsafe || (User.mana + converted) <= User.maxMana){ 
    // This branch is entered when all converted mana is absorbable, or the [Overcharged]
    // failsafe is disabled.
    // Channel the converted energy to the user. Note the chained `orderly` modifier!
  } else {  
    // This branch is entered when the captured energy is too much to give to the user in full.
    // The following line detects any plastic nearby using the relevant variant of the 
    // `detect` thaum. 
    // Note that most common molecular structures are exposed in the `Material` namespace!
    const buffer = Material.detect<Material.Polymer>() with Shape(sphere);
    // Calculate how much mana the user can currently absorb before getting overcharged.
    const maximum = User.maxMana - User.mana;
    // Calculate the extra mana left.
    const overflow = converted - maximum;
    // Send the maximum possible mana to the user.
    // Check if any plastic was found.
    if (buffer) {
      // Send the overflow to the plastic.
    } else {
      // When there’s no plastic to be found, we can’t store the mana, and if we don’t release
      // this excess mana during the same tick, something bad could happen to the spell
      // because excess energies can’t be released automatically, yet!
      // Possible solution: make plastic with the excess mana and store mana into it?
      // Temp solution: try to invigorate the user using the excess mana.
      User.infuse.orderly(overflow as Energy.Life);
    // The user’s mana is full, end this spell now.

// End the spell when the tick number exceeds the duration. Will be disabled if 0 is passed
// as the duration.
when(duration != 0 && history.tick >= duration) {

It was more straightforward than he expected, although his old habit of recording his thoughts verbatim in code comments manifested itself as soon as he began.

In the end, he’d coded what he considered to be a very good proof-of-concept state machine. Because that was what a spell – by definition – was: a finite state machine with well-defined inputs and rules to follow in every situation.

He reviewed the program again, adding more of his thoughts in the comments. He felt dissatisfied with some aspects of this syntax, but he’d deal with those later. At least this version of the spell had a safety feature and a finite duration!

Another fact cheered him up, though. He could now specify the radius of the sphere in millimetres and the spell duration in seconds. This was the greatest difference to manipulating the spell model directly as he was used to: by manually – or automatically via AI calibration – adjusting thaums to the desired intensity.

Instead, this new language allowed him to use actual units of measurement from his world directly whilst designing spells, and the compiler would take care of the rest.

This software design pattern he’d just introduced was called when[5] and involved something called ‘event-based programming’. It was directly inspired by gene expression, and was widely adapted at one point in the past with the advent of adaptive chips designed for real-time applications, but was no longer dominant in the software markets of his world.

It was simple, really: DNA was a collection of chromosomes, and those were collections of genes. Each gene was made of basepairs, and those could be further divided into regions, the relevant of which – in this case – were the activation region and the coding region.

To understand this pattern, you had to consider a cell’s nucleus that’s frozen in time as the current state, and a tick to be the smallest possible discrete unit of time representing how long it took to evaluate the entire DNA strand and the genes engulfed within. In this vision, every single gene was made up of a tuple: an activation condition – an activation region in genetic terms – with an attached action – the coding region – that was made of executable instructions.

With every ‘tick’ that elapsed, only the genes with an activation condition not inhibited by the current state would be expressed, and each expression of a gene served to alter the ‘state’ from the current to the next, thus ‘mutating’ the current state into the next and advancing time by one tick.

Of course, the newly mutated state would trigger a different set of genes on the next ‘tick’, and those would further mutate the state, triggering even more genes with more complex activation conditions, and so on and so forth.

The original software design pattern took this a step further, actually. It would save a history of elapsing states in a one-dimensional history vector, each identified by index as a concrete tick in time. You could rewind back in time and have your program revert back to a previous state whilst taking back information from ‘the future’. It was a powerful concept that was usually overlooked, except for traversing data structures like graphs and trees, in which case it was a great boon to have.

Unfortunately, it wasn’t possible to implement such advanced features here, and that included another feature: DNA-like recombination. That was dangerous, because living spells capable of reproduction could destroy the universe by uncontrolled reproduction, and the former temporal model was simply not feasible, since it would drive the spell out of sync with reality without super-complex logic to recover or accompanying temporal thaums.

“Nothing to be done about that, I guess.” Ethan shrugged and whispered, “It’s the perfect pattern for the job, though.”

A roaming spirit looked up at him from the corner, “What?” asked [Commander] Talius, who had just returned from roaming outside and was apparently deep in his own thoughts.

“Nothing, just talking to myself,” Ethan said.

“You are a strange man, Ethan West. Aylin has spoken to me about you,” the spirit responded.

“You know Aylin Merza?” Ethan lifted an eyebrow, curious.

“Ah, yes. One could say that she’s the reason for my early retirement.” the spirit snorted.

“You’ve returned early today,” Ethan observed quietly while hitting the ‘compile’ button on his UI.

“Yes, I met with Aylin, who has admittedly changed quite a lot,” the spirit said, before he started pacing in his ethereal body. “She told me of you, and mentioned that you are the [Harbinger] of Science? A new aspect with great potential from another world?” He paused, contemplating something very deeply.

“She’s not my goddess,” Ethan said adamantly, “she’s theirs. I’m just a traveller passing through your realm.”

“So it is true, you are from another world?”


“Then I have a question, and a request,” the spirit said hesitantly.

A chime sounded, indicating that the compilation of the new spell was complete, but Ethan ignored it for now. He nodded at the spirit to elaborate.

Jarret Lytell was lost.

He’d crawled, he’d begged, he’d eaten maggots from refuse piles.

He’d finally discovered he was mad, when a passing [Priest] on a prairie offered to bless him. He’d almost rejected it, but luckily, something made him accept, and that was how he’d regained his mental faculties.

Now sane again, he was still lost, and he was bitter at his treatment by The Hands, the Polarii Empire’s secret service.

Thankfully, he was no longer completely helpless. With the return of his sanity, his magic was coming back to him, slowly but surely, allowing him to hunt his own food in the wilderness. Which was what he’d been doing for a long while. What he was doing right now, actually.

He hunted, and he traded pelts for what he needed. He was afraid of going too close to a city – lest The Hands have a bounty on his head – but he managed to contact a few nearby villages, and lived the life of a lonely hermit.

He didn’t mind this new life too much, though. His temporary dwelling wasn’t that bad. It was an abandoned cave he’d come across while hunting Feywolves. They were a vicious breed of wolf with an affinity for the wind, but as a [Hydromancer] he could asphyxiate them to death and collect their valuable pelts intact, an advantage no other hunter could claim to have.

His current life wasn’t that terrible, but compared to his old life as the second son of a noble serving in the military… well, he didn’t want to dwell on that; but his anger grew, and so did his bitterness.

Feywolves were becoming harder and harder to find as of late, and he found himself ranging farther and farther afield, just to spot any tracks or evidence of their passing.

With winter at the door, it was a given that they would soon migrate higher into the mountains. The only option left to him was to climb and go into the Krashi mountains, where the Krell made their homes.

Jarret stood at the base of the mountains, contemplating going further or going back. He looked up at the heights, and the celestial tree peeking out of the volcanic crater with awe.

Firming his resolve, he made a decision.

  1. No such band, I hope you appreciate my secret musical aspirations. ↩︎

  2. Branes are the foundation of M-theory/String Theory. ↩︎

  3. Wikipedia ↩︎

  4. Integrated Development Environment, an editor of code. ↩︎

  5. In a strange case of Reverse Science-Fiction, I’ve already made a real-life proof-of-concept implementation and a spec, both of which are available here. ↩︎