This in its original form was called:
Cullen’s Guide to Thread Construction
This is what I call “thread construction”. Others might have done this before but, I’ve been delving into it recently and have found it to be quite remarkable. The original author, Cullen, coined the term.
Prerequisites:
- Proficiency in controlling substantial amounts of energy.
- The ability to mentally maintain multiple constructs in a stable state.
- Capability to leave constructs undisturbed for more than three days without them dissipating.
- A substantial level of expertise in construct manipulation, as this is not a beginner-level skill.
The essence of this programming technique involves the creation of highly adaptable and compact constructs, which we like to refer to as “Threads.” Creating a Thread construct involves two primary steps:
- Concentrating a significant amount of energy at a specific point in space without programming it, merely guiding it with your mental focus.
- Generating a minuscule amount of programmed energy, which functions as a thread.
That’s all; now let’s delve into the fascinating implementation. This method commences with a basic psiball, but it doesn’t require a large energy reserve. Concentrate a substantial amount of energy (approximately half of what’s needed for a “strong” psiball) into an area roughly the size of a dime or 5p coin. Next, program it with a few general commands and the specific instruction you desire. For instance:
- Maintain cohesion.
- Mould energy into a spherical shape around threads.
- Divide into threads.
- Preserve a compact thread shape.
Commands three and four often synergize and can be programmed simultaneously. The thread then takes charge of the energy, employing it according to its programming, effectively creating a uniformly programmed psiball or any other construct, with only a small portion being programmed. While this is intriguing, the truly remarkable aspect lies in what follows. You now possess a psiball that doesn’t require external containment since it’s controlled by internal threads. Moreover, you can incorporate numerous thread networks within the same psiball. For practice purposes, let’s introduce another set of threads. Program another small cluster of energy to emit an energy “ping” every few seconds. Integrate it seamlessly with the threads holding the psiball together. You could also add a third network designed to draw energy back into the ball from yourself or a nearby source. All these tiny constructs tap into the same energy reservoir simultaneously, creating a fabric of programming. As long as you avoid conflicting programming, you can fit multiple programs into the same psiball. Plus, you can “unweave” it by extracting the threads, without the need to de-program the original psi, as it was solely harnessed and shaped by the thread constructs (especially useful for energy recycling).
This construction method has additional effects that I’ve observed. When you scan a construct created using this method, you won’t detect the presence of threads from the outside. It appears as a typical construct externally, but once inside, you can differentiate between the various threads. The key lies in the thread programming itself. You must have a clear mental concept of each thread’s function once it enters the energy ball. For instance, if you want to contain the energy in a shell, you must incorporate a thread that forms an outer shell. If you desire a specific shape, add another thread governing its form. The closer you place the threads, the more you can weave into the construct, limiting the method’s scope only by your construct-creating capabilities.
As an additional note, if you’re confused about creating threads:
- Generate the compact energy.
- Program it.
- While it remains condensed, encourage it to wind itself into an even tighter thread.
- Strengthen the programming that maintains the thread’s shape.
- Avoid overloading it; I’ve experienced cases where excessive energy flow into the construct resulted in the thread losing its programming.
Lastly, let’s discuss weaving the threads into the construct. I’ve found that different patterns work well for different objectives. For instance, if you want a thread to control the shape, establish a central point and have the thread extend outward in spokes, connecting to the outermost part of the energy, thus giving it control. Threads responsible for power regulation or shelling should be woven into a mesh on the construct’s outer surface. If you want to introduce an enhancement or ensure that others don’t lose their programming, weave it throughout all the constructs from the inside out, connecting it to all the other threads and securing it at various points.
Some challenges I’ve encountered:
- Threads can unravel if not programmed precisely, leading to construct destabilization.
- Raw energy programming can clash with thread programming, so avoid accidentally introducing shape-related programming into the raw energy.
- While unweaving threads from the construct is relatively straightforward, de-programming and destroying them can be challenging if they’ve been properly crafted and are resistant to programming changes. To simplify cleanup, consider enveloping the threads with energy programmed to “dismantle” or “eliminate” them. Then, you only need to de-program the conventionally programmed psi-ball instead of attempting to destroy a hair-thin, densely packed energy thread.
That concludes my guide to Thread-Based Construction. I hope you followed along, and if you have any questions or need clarification, please don’t hesitate to reach out to me via private message on the forums or in chat.
Enjoy experimenting with this technique…