DEV Community: Emi

The Particle That Walks Through Walls — And Why Your Phone Depends On It

Emi — Mon, 23 Mar 2026 17:31:16 +0000

Imagine throwing a ball at a wall.
The ball doesn't have enough energy to climb over the wall.
So it bounces back. Obviously. Every time. This is not a controversial statement.
Now imagine the ball is an electron.
Sometimes it goes through the wall anyway.
Not over. Not around. Through the wall itself.
This is quantum tunneling. It is not science fiction. It is not a metaphor. It is a measurable, reproducible physical phenomenon — and it is happening right now, billions of times per second, inside the device you are reading this on.

The wall is a probability, not a fact
In classical physics, a particle either has enough energy to cross a barrier or it doesn't. The wall is real. The outcome is certain.
In quantum mechanics, nothing is certain until it is measured.
A particle exists as a wave function — a mathematical object that encodes the probability of finding the particle at every point in space. This wave function doesn't stop at barriers. It penetrates them. It decays exponentially inside the barrier — but if the barrier is thin enough, the wave function emerges on the other side with a non-zero value.
Non-zero value means non-zero probability.
Non-zero probability means: sometimes, the particle is on the other side.
That's it. That's the whole trick.

"The wave function approaching the barrier."

How thin is thin enough?
The transmission probability follows an exponential law:
T ≈ e^(-2κL)
Where L is the barrier width and κ depends on how much energy the particle is missing.
The exponential means: double the barrier width, and the probability doesn't halve — it drops by orders of magnitude. This is why tunneling only matters at atomic scales. A tennis ball tunneling through a wall has a probability so small it would take longer than the age of the universe to observe it once.
But electrons are light. And in modern transistors, the barrier layers are only a few nanometers thick.
At that scale, tunneling is not a rare event. It is routine.

The Sun is powered by the impossible
Here is something that should bother you.
The core of the Sun is hot — around 15 million degrees. But even at that temperature, protons don't have enough kinetic energy to overcome the electromagnetic repulsion between them and fuse.
The Sun should not be able to fuse hydrogen. The nuclear reactions that power it should not be happening.
And yet they are.
The protons tunnel through the Coulomb barrier. The probability is small — any given pair of protons will almost certainly bounce off each other. But there are an incomprehensible number of protons in the Sun's core, and they're colliding constantly.
The Sun shines because of quantum tunneling.

I built a simulation
I wanted to understand this more concretely. So I solved the time-dependent Schrödinger equation numerically — the equation that describes how wave functions evolve — and built an interactive simulation.
You fire a wave packet at a barrier. You watch it hit. Part of it reflects. Part of it — a small, eerie part — appears on the other side.

"Reflected wave (left) and tunneled wave (right). Same particle. Same barrier."

The simulation lets you change the barrier height and width in real time. Increase the barrier — the tunneled wave shrinks. Make it thinner — it grows. The exponential relationship is visible directly.
What I found is that building this forced me to confront something I had glossed over when reading about tunneling: the wave function doesn't "try" to get through and sometimes succeed. The wave function is everywhere simultaneously, including inside and beyond the barrier. The question is not whether it penetrates — it always does. The question is how much of it makes it through.
The particle isn't sneaking through a gap in the wall. The wall was never as solid as it appeared.

What this means for your phone
Modern transistors — the switches that perform every computation in every processor — work by controlling electron flow through thin semiconductor layers.
As transistors have gotten smaller, quantum tunneling has become a serious engineering problem. When the insulating layers are only a few atoms thick, electrons tunnel through them even when they're supposed to be blocked. This creates leakage current, wastes energy, and generates heat.
Every processor generation, engineers have to work harder to manage tunneling effects that classical physics said shouldn't exist.
The quantum weirdness that powers the Sun is also the quantum weirdness that limits how small your phone's chip can get.

The deeper strangeness
There is something about tunneling that I keep thinking about.
The particle doesn't "go through" the wall in any classical sense. It doesn't drill a hole. It doesn't find a weak spot. The wave function simply extends beyond the barrier, and there is a probability of finding the particle there.
What is the particle doing while it's "inside" the barrier?
According to standard quantum mechanics — nothing. The question is meaningless. The particle doesn't have a trajectory. It has a wave function. And the wave function is doing exactly what wave functions do: spreading, decaying, emerging.
The wall was never a wall. It was always a probability gradient.
And that is strange enough to be worth sitting with.

Try it yourself
🔗 Live demo: https://emineugurlu.github.io/double-slit-simulation/
💻 GitHub: https://github.com/emineugurlu/double-slit-simulation
Fire a wave packet. Watch it tunnel. Adjust the sliders. The physics is real — the numbers come from the actual Schrödinger equation.

The series so far

✅ Double-Slit Experiment — wave-particle duality
✅ Wave Interference — the physics behind the fringes
✅ Quantum Tunneling — particles through walls

Next: Schrödinger's Equation — visualizing the wave function in a potential well.

Your phone works because electrons do the impossible. The Sun shines because protons do the impossible. We built civilization on quantum weirdness we still don't fully understand. I think that's extraordinary.

Non-zero value means non-zero probability.
Non-zero probability means: sometimes, the particle is on the other side.
That's it. That's the whole trick.

"I Built a Quantum Physics Simulator in JavaScript — And It Broke My Brain"

Emi — Sun, 22 Mar 2026 16:36:48 +0000

I Built a Quantum Physics Simulator in JavaScript — And It Broke My Brain

I'm going to tell you something strange.

An electron can pass through two holes at the same time.

Not metaphorically. Not "as if it does." Physically, literally, through both holes simultaneously.

And I wrote a simulation to prove it.

You've heard of this experiment. You probably got it wrong.

The double-slit experiment is usually described like this: "Electrons behave like waves."

Okay. But what does that actually mean?

It means: fire an electron. Let it pass through two slits. Look at the screen.

Expected: two bands.
Reality: dozens of thin stripes. An interference pattern.

Fine. Wave behavior. Got it.

But here's the part that actually matters.

Fire electrons one at a time. One electron. Wait. Another. Wait.

After hundreds of electrons — look at the screen.

The interference pattern is still there.

A single electron interfered with itself.

Then turn on the detector — just to see which slit it went through.

The interference pattern vanishes. Instantly.

The act of looking changed the result.

Coding Made It Click

To compute the interference pattern, you need this formula:

I(y) = (ψ1 + ψ2)^2

Add first, then square. The order matters.

Add first → both waves interact → interference happens
Square first → each slit is independent → no interference

In the simulation, for each pixel we compute:

ψ = A · e^(-(Δy²) / (2σ²)) · e^(i · 2πr / λ)

When physicists say "the electron passes through both slits at once," this is exactly what they mean mathematically. ψ₁ and ψ₂ exist simultaneously and interact.

I only truly understood this when I had to write it in code.

How I Built It

For each electron, I do two things.

1. Compute where it will land:

function computeScreenIntensity(y, slits) {
  let re = 0, im = 0;
  slits.forEach(slit => {
    const r = Math.sqrt(L*L + (y - slit.y)**2);
    const phase = 2 * Math.PI * r / lambda;
    const envelope = Math.exp(-(dy*dy) / (2*sigma*sigma));
    re += envelope * Math.cos(phase);
    im += envelope * Math.sin(phase);
  });
  return re*re + im*im; // |ψ|² — probability density
}

ψ₁ + ψ₂ interaction produces interference. High value = electron lands here more often.

2. Sample from that probability (rejection sampling):

do {
  y = random point
  prob = computeIntensity(y) / maxIntensity
} while (Math.random() > prob)

The electron doesn't land randomly. It lands probabilistically — guided by the wave function.

The pattern doesn't appear instantly. Each electron adds one dot. After hundreds of hits, the interference pattern slowly emerges — exactly like the real experiment.

One Line of Code Kills the Pattern

When the detector is on, the code does one thing:

activeSlits = [slits[Math.random() < 0.5 ? 0 : 1]];

Only one slit is active. ψ₁ + ψ₂ becomes just ψ₁. No interaction. No interference.

The pattern disappears — not because of some mysterious quantum magic, but because the math changes.

Both amplitudes need to be present at the same time for interference to exist. Remove one. Pattern gone.

"Left: detector off (wave). Right: detector on (particle)."

The Question That Has No Answer

Okay. The detector turns on, the pattern disappears. Why?

Physics says: "The wave function collapsed."

But why did it collapse?

This is where physicists still disagree — loudly.

Copenhagen: Before measurement, position didn't exist. Now it does. Don't ask why.

Bohm: The electron always had a position. An invisible pilot wave was guiding it.

Many Worlds: The wave function never collapsed. The universe split in two. You're living in one branch.

Which one is correct?

Nobody knows.

And I think the absence of an answer is more interesting than any answer could be.

The Wave Interference Simulation

To make the physics behind the double-slit visible, I built a second simulation.

Two point sources. Waves spreading outward. They meet and interfere.

const phase = (2 * Math.PI * r) / lambda - time;
total += Math.cos(phase); // superposition of two waves

time increases every frame — waves animate. Green = constructive. Pink = destructive.

Each slit in the double-slit experiment is a wave source. The fringes you see on the screen are exactly what two interfering waves produce.

"Wave interference simulation — two sources, infinite patterns."

The wave interference simulation makes this intuitive in a way that equations never could.

Try It Yourself

🔗 Live demo: https://emineugurlu.github.io/double-slit-simulation/

💻 GitHub: https://github.com/emineugurlu/double-slit-simulation

Toggle the detector. Watch the pattern collapse.

Drag the detector strength slider slowly — watch the pattern fade gradually. That's decoherence in real time.

What's Next

Quantum tunneling is coming — a particle passing through a barrier it classically has no right to cross.

The phenomenon that makes modern electronics possible.

If you want to see it when it drops — follow me here. I'll be building it the same way: physics first, then code, then simulation.

If this made you think, or if you want to argue about interpretations of quantum mechanics — drop a comment. I'm here for it.