The Real Reason Behind the RAM Price Explosion You Didn't Know: Dissecting the Hidden Side of KOSPI 5000

Recently, my younger sibling's computer got old,

so I decided to upgrade it to new specs.

Fitting for the age of AI, putting together a computer build with AI's help,

I was living a smart everyday life.

But then, lo and behold,

the price of the RAM card in the build I'd put together was so expensive

that I was told not to buy it here??

As if that vendor were some price-gouging scam shop..

In step with the advancement of AI,

what's now being called 'chipflation' —

the current semiconductor crisis —

turned out to be news that hadn't reached the AI's knowledge yet, which surprised me.

In January 2026, the KOSPI broke through the 5,000 mark for the first time in history. Behind the cheers that Korea's capital market had leveled up lies the semiconductor boom at SK Hynix and Samsung Electronics that drove KOSPI 5000.

But behind this massive celebration,

ordinary consumers, myself — a gamer geek — included,

could not help but shed tears

over semiconductor prices that had skyrocketed through the roof.

What on earth happened? T_T

You might think this is old news, but let me be clear: this piece isn't a prediction — it's merely a 'retrospective' looking back at the results..

---

I think it's best to start with the story of 'AlphaGo.'

Before AlphaGo, known as a deep learning model, appeared,

Go was not a domain that algorithms could conquer.

But deep learning approached this in an entirely new way. For instance, a model can be defined as f(x).

For an arbitrary dataset,

$ax^2+bx+c=f(x)$

like this,

the technique of ceaselessly adjusting degree and coefficients to find the function that best fits — namely, 'curve fitting' — was the answer.

How would you express this process computationally?

It can be expressed as 'matrix multiplication.'

A matrix is a matrix, and a function is a function..

Since I'm not very bright,

I didn't understand at first how f(x) could be handled with matrices.

Not until I learned how to solve systems of equations using matrices, that is.

Anyway,

increasing the degree and coefficients in this way means adjusting the dimensions and the values of the elements. This matrix (vector space), called training data, becomes the model.

Now, this 'trained' f(x), for arbitrary data,

can have the model's score evaluated based on how well it 'fits.'

In other words, by favoring the values with higher scores (the ones receiving more reward), you can gradually determine an f(x) that approximates the dataset as closely as possible.

This inductive method found a clue to the unconquerable domain of Go. For reference, the paradigm of conventional computing had been 'deductive.'

Through this principle, if you train the correlation between the order and position of stone placements and the win rate onto a vector space, then depending on the scale of that training, it becomes a model that can know and follow the win rate for 'almost every possible move.'

This model is none other than <AlphaGo>

It succeeded in moving this seemingly unconquerable game of Go onto a vector space. It was an era that brought about the fear of the so-called 'Singularity.'

Before going any deeper, let's get back to the main point,

you might be wondering, 'what does this have to do with GPUs?'

Everything related to today's AI is connected to this 'matrix multiplication.' Also, this means it isn't impossible to do with a CPU.

Suppose you're processing the multiplication of matrices like these.

The CPU (Central Processing Unit), even though each step, like 'ae + bg + cf + dh', isn't complicated, completing the entire computation requires repeating the CPU's characteristically long and tedious operations 'serially.' This is precisely the 'bottleneck' that occurs when a CPU processes matrix multiplication.

The GPU (Graphics Processing Unit), on the other hand, was originally a tool for simultaneously processing the pixel colors at each coordinate on a gridded screen.

From birth, it was optimized for what's called vector computation.

Because it processes countless matrix multiplications in parallel all at once,

it was overwhelmingly more effective than a CPU.

This is why the computation tool optimized for vector space processing

ended up being the GPU, not the CPU.

---

Next, we need to talk about LLMs (Large Language Models). Today, when people say "artificial intelligence" — think ChatGPT, Gemini, Claude — it's practically synonymous with LLM models. (Strictly speaking, LLMs fall within the domain of artificial intelligence, but it's hard to consider them full-fledged AI.)

Naturally, before LLMs, there was LM (Language Model) — the language model.

It used to be simple.

If you asked 'hello,' it would answer 'nice to meet you' —

there were models that answered in a fixed (static) way.

Taking this a bit further,

you could implement an LM by tokenizing words through morphological analysis, using that to normalize them into vectors as a BoW (Bag of Words), and then finding similar sentences using cosine similarity.

Finding a similar sentence means finding its corresponding value, which can be seen as a semantic interpretation within a defined category. It's a method of connecting to the most appropriate corresponding value within the domain, and past chatbots took this form.

LLMs took the scale of this vector space and grew it astronomically. By defining the topology between words as vectors, and just as AlphaGo predicted probability orderings based on move sequences, they built a model that predicts the order of the next word.

That's precisely the Transformer model.

What does it do with this? It performs text completion — filling in the blanks of a sentence.

Then someone had an idea.

If we grow this scale enormously, wouldn't it get really good at completing sentences?

And so, something called GPT emerged.

GPT stands for Generative Pretrained 'Transformer.'

It's a Transformer model that has already been pretrained. And using this model, the results come out looking as though they're being 'generated' — that's precisely GPT.

But then some other clever person thought,

'Then, if we train it on conversations between people, couldn't we complete a model that answers questions too?' If we train it on a huuuge number of conversations, wouldn't it become something that answers questions as well? — that's precisely the 'conversational model,' ChatGPT.

[Note] The unfamiliarity called creativity

In this process, the concept of 'hyperparameters' comes into play.

If, in text completion, you always let it predict only the next word with the highest probability, you end up with only obvious and boring output.

At this point, by adjusting the Temperature value to induce the placement of statistically low-probability (unfamiliar) words, sentences that appear remarkably unfamiliar and novel to humans are born. We cheered this on, saying "AI invented creativity," but from a technical retrospective standpoint, this too looks like the product of sophisticated probability tuning.

Surprisingly, every time the parameter size and scale were increased, the LLM got smarter.

The golden age of scaling had arrived.

As for how smart it got — it reached a level where it could give reasonable answers to almost everything.

In other words, since computers ultimately run on API calls, once answers could be submitted as commands rather than mere text, triggering that value made command execution possible too — and, in conclusion, AI became able to 'computationally' think and act.

For this era to arrive, there was massive investment from big tech,

and a new era opened up where the more capital that was burned, the smarter the model became.

OpenAI CEO Sam Altman made a fuss about this, calling it comparable to the 'Manhattan Project.'

Anyway, in this scaling process, the parameter size kept growing — 7B (Billion) -> 16B -> ... -> 70B — and that's where emergent abilities exploded.

Looking at it now, this scale is child's play, but at the time, the scaling curve appeared to be trending 'upward and to the right.'

(Also, something I only realize now: this curve was actually a sigmoid curve, and it's reportedly nearing some kind of plateau at the moment.)

Regardless, this scaling generated astronomical demand, and demand for GPUs overflowed.

In no time, Jensen Huang became one of the ten richest people in the world.

As AI advanced, demand for GPUs naturally increased. So far, we've only been talking about GPUs.

So what does this have to do with the RAM price explosion?

Now let's talk about GPUs for a moment.

The GPU (Graphics Processing Unit) is, at its core, about 'Processing' — the computation domain.

That's why the computation unit and memory must constantly exchange data.

To use an analogy, it's like this.

When we do math in our heads, there's the part where we 'calculate' mentally, and the part where we 'write' on a notepad. The role of the mind is 'computation,' and the role of the notepad is 'memory.'

But here, a fatal problem arises.

No matter how fast the GPU finishes its computation, a bottleneck occurs in the channel (pathway) that sends data to memory and brings it back.

Also, no matter how much you increased the channel's transfer speed, it was useless if the memory side couldn't keep up with that speed.

How could this be solved?

What if we just got rid of the channel?

How did Choi Min-sik succeed early on in the drama Casino?

'Man, why bother with all that three-cushion routing? We can just hand it over in cash.'

But even if you eliminated the channel, at the current level of integration density, there simply wasn't enough physical space next to the GPU to place 'high-spec memory.'

Here, yet another clever person came up with a solution — HBM (High Bandwidth Memory).

How did HBM solve this? Rather than increasing integration density, it stacked memory up and down like a tower.

From the GPU's perspective, this became an excellent solution to the current physical constraints.

So, against this backdrop,

big tech investment in AI increases ->

demand for GPUs increases ->

and demand for memory like HBM increases along with it.

However, HBM used to have the reputation of being 'an expensive, low-profit boondoggle.' To use an analogy, it was like buying a Ferrari.

In the current climate, demand for HBM didn't just increase moderately — it increased 'enormously, astronomically.'

So what happens to semiconductor manufacturing processes around the world?

A major tectonic shift occurs.

The original semiconductor fabs weren't places that produced Ferraris,

but processes that produced ordinary Elantras.

In other words, they were places that made semiconductors like DRAM and NAND, consumed by ordinary folks like us gamer geeks.

But now, from a company's perspective,

it's far more profitable to focus on the Ferrari (HBM) that's selling out no matter how much you make, rather than running factories to squeeze small change out of consumers like me.

As the saying goes, you row while the tide is in your favor,

so they immediately switched over to HBM production processes.

No need to overthink it — this wasn't because anyone ordered it,

but rather Adam Smith's supply-and-demand curve, the invisible hand —

you could say that hand demanded HBM be made.

This isn't some foreign story — behind the overwhelming earnings of SK Hynix and Samsung that drove KOSPI 5000 was precisely this 'HBM' business.

So what happens now?

Did demand from gamer geeks like me decrease just because AI demand increased? Not at all. It stayed the same.

Supply dropped exponentially, but demand stayed the same.

It's obvious what happens next. The era of 'chipflation' — the so-called memory price explosion — arrives.

In conclusion,

the price of DDR5 memory right now has skyrocketed to roughly 5 to 10 times its original launch price.

[E.o.F😛]