Episode 022| The Hacker Who Debugs

???

Lika stared at the seed.

The carving redrew once a second.

At first he took the patterns for random recombination; it was only after watching for about 20 seconds that he realized—not random. Every redraw, a few of the lines gained a little more curvature than the time before, or one more bend.

Like someone slowly carving it. Pushing it from one version toward another, step by step.

"What are you changing in it," Lika said softly.

A statement.

—

Only now did he notice.

The light flowing through the passage's ice crystals had slowed.

Originally each crystal went from bright to fully dark in 1.6 seconds—the standard cycle he'd measured the moment he entered the Instance, the whole layer sharing one clock.

But now that cycle had become 1.9 seconds.

And the slowing was uneven—some panels were still 1.6, some dragged out to 2.1. The whole layer's beat was starting to fall apart.

Lika crouched and pressed his palm flat against the floor crystal.

The crystal underfoot brightened more slowly than before; he could feel it. From bright to fully dark, by his estimate, 2.4 seconds.

The brain-chip interface jumped:

[Layer 1 system clock drift: +0.8s average]
[Render queue load: 89%]
[Source: L.K.S._Core ongoing write operation]

Lika finished the three lines and stared at "89%" to confirm it once more.

The Instance was jammed. The render queue was nearing full load—ninety percent of the whole layer's compute was eaten by this operation, "the past him writing the seed."

He'd seen hundreds of scenes like this—some process eating too much CPU, the whole system starting to stutter, the interface starting to glitch, animations starting to drop frames.

It wasn't that the Instance had no safeguard—it had this 89% threshold warning, which meant it knew it was about to blow.

And yet it still let L.K.S._Core keep writing.

The Instance placed no ceiling on this signature's permissions.

—

"Good," Lika said softly.

He straightened and walked forward down the passage.

On the third step he stopped.

—

A patch of the ice-crystal wall to his right had glitched out.

The crystal hadn't shattered. A small region, maybe 30 centimeters square, simply hadn't been rendered. He couldn't see the crystal's texture, couldn't see what lay behind it.

He saw only a pure black base color, with extremely fine gray grid lines floating over it. Each cell was about 1 centimeter square.

The underlying layer, exposed.

Lika moved closer to the glitched patch.

The brain-chip interface jumped:

[Layer 1 visual buffer: local fault]
[Reason: render queue saturated · partial model cull]

"Cull," Lika read softly.

The render queue had passed its warning threshold; the Instance couldn't draw every model in time, so it discarded selectively—not drawing regions of low visual priority.

This glitched patch was now the Instance's code layer directly exposed.

Normally the Instance would redraw it within 0.5 seconds, but because the render queue was still at 89%, this patch lingered, unfilled.

—

Lika watched the glitched patch, and an image surfaced in his head.

The first hacking technique he'd ever learned, back in his university days.

Race conditions—when a system can't keep up, the permission check can get skipped. Slip your command into a high-priority operation the system is already handling, ride in on its back, and the system has no time to check whether you have permission—and this Instance was, right now, in exactly that state.

The Instance was in exactly that state right now. "The past him" held 89 percent of the compute. "The present him"—himself—observer permissions—was low priority.

But he could piggyback.

Lika held still for 3 seconds.

He wrote a command in his head.

The interface would run a permission check. He called out to the Instance directly with his thoughts:

query: where is the exit from Layer 1.

Normally the Instance would refuse this question. An observer had no permission to query the Instance's structure.

But right now the Instance was busy—

The brain-chip interface jumped:

[Permission check skipped: render queue overflow]
[Query executed: Layer 1 exit]
[Result: 3 exits with known coordinates / 1 exit with unknown coordinates]
[Layer 2 entrance located at: ???]

Lika looked at that "???" line.

The Instance knew the answer. And the answer was "unknown."

The brain-chip interface jumped a second line:

[Layer 1 unlock depth: 3/4]
[Instance progress: 19.4%]

Lika finished reading both. He went still for 2 seconds.

—

Then the Instance caught on.

The brain-chip interface jumped a third line:

[Notice: unauthorized command injection]
[Source: ??? · observer ID mismatch]
[Response: ??? · processing]

Lika looked at the "Response: ??? · processing" line.

The Instance knew someone had just slipped a command in. But it couldn't trace the source. Lika suspected the source had been buried under L.K.S._Core's write operation.

The Instance was now asking itself how to handle it.

—

Lika let out a soft breath.

He found the corner of his mouth tilting up slightly—he'd done the same thing many times, but today's was a little different. Today the system, the one who wrote it, was himself.

"Interesting," he said softly.

—

【Ch. 022 End · Inside the Instance · Rift Memory Layer 1】