Coding metamaterials, digital metamaterials and programmable metamaterials

Tie Jun Cui, Mei Qing Qi, Xiang Wan, Jie Zhao, Qiang Cheng•View original

OverviewBalancedalloy voice

If you've spent any time around metamaterials, you've heard the usual story: treat the structure like a smooth medium, tune its effective parameters, and hope the wavefront obeys. Tie Jun Cui and colleagues flipped that script. Back in 2014, in Light: Science and Applications, they argued you can stop thinking analog and start thinking digital. Not "digital" as a metaphor — literally coding the surface with bits. A unit cell that gives you a phase of zero becomes a zero. A unit cell that flips the phase by half a wavelength, or 180 degrees, becomes a one. String those zeros and ones across a surface, and you don't just set an effective index. You program what the wave does. Let's make that concrete. Start with the simplest case: one-bit coding. You have two kinds of square metallic patches on a dielectric — one plays the zero state, and the other the one. The trick is to pick the patch sizes so their reflected phases stay almost exactly opposite over a broad band. In their static, printed design, the "zero" patch was wider than the "one" — roughly 4.8 millimeters versus 3.75 millimeters — and on that stack, the phase gap stayed near 180 degrees across about 8.1 to 12.7 gigahertz. It wandered between roughly 135 and 200 degrees, but the two elements aligned to a clean 180 at a couple of spots. That's important. If your binary elements keep that phase opposition, the whole coding idea holds together, and you can treat the surface like a big, programmable diffraction grating. Now, what happens when you start writing actual codes across that lattice? Here's the intuition: each cell contributes a phase, either zero or pi, and the far field is just the coherent sum of all those little contributions, like an array factor multiplied by an element pattern. Cui and colleagues wrote it down formally, but you don't need the equations to see the consequences. If every cell is the same, all zeros or all ones, the surface behaves like a single, flat mirror and throws most of the energy back along one direction, mimicking a perfect magnetic conductor or a perfect electric conductor. If you alternate zeros and ones in a simple sequence, like zero, one, zero, one, zero, one, you build a grating and split the reflection into two symmetric beams. Mix the stripes — zero, one, zero, one, zero, one here, one, zero, one, zero, one, zero there — and you can pull four main beams. The key is that you're not carving a new lens every time; you're just changing the pattern of bits. There's more you can do when you let go of perfectly periodic codes. The team asked a radar question: can we spread out the reflections so no direction sees much energy? That's radar cross-section — RCS — reduction by diffusion. With optimized one-bit sequences on an N by N lattice, they suppressed the monostatic RCS more and more as N grew. The headline number is this: by the time they got to N equals 20, the reduction was about 23.6 decibels compared with a flat reflector. And it wasn't one of those needle-thin, one-frequency tricks. In the backward direction, the reduction stayed around 10 decibels across roughly 7.8 to 12 gigahertz. Two robustness checks matter here. First, the design kept working even when the phase gap between the zero and one elements drifted — anywhere from about 145 to 215 degrees still bought you at least 10 decibels of reduction. Second, the spacing of the lattice relative to wavelength could swing a lot — from 0.6 to 3.0 — without spoiling the effect. That means you can scale or retune without breaking the core idea. So far, this is a printed, static surface. But Cui's group wanted it to be alive. They built a reconfigurable particle — a tiny, symmetric metallic structure on a low-loss substrate with a single diode bridging the halves. No bias, the diode is off, and the particle behaves like the zero element. Push a small direct-current voltage of 3.3 volts, and the diode turns on; the particle flips to the one state. In simulations, the phase difference between off and on sat near 180 degrees from about 8.3 to 8.9 gigahertz, and it nailed 180 at 8.6. Now you're not just printing a code. You're toggling it. Arrange thirty by thirty of these particles into a metasurface, wire them so you can address columns, and give the whole array a brain — a field-programmable gate array or FPGA. In their demonstration, every five adjacent columns shared a control line, and the FPGA switched sequences on command. Four hard-coded patterns — zero, zero, zero, zero, zero, zero; one, one, one, one, one, one; zero, one, zero, one, zero, one; and zero, zero, one, zero, one, one — were loaded up like presets on a synthesizer. Flip a switch, the FPGA streams out the voltages, the diodes go on or off, and the wave does something different. At 8.6 gigahertz, the measurements line up with the codes you've just heard in your head. All zeros, all ones: a single, strong reflection, as if the surface decided to be a magnetic wall or an electric one. The alternating zero, one, zero, one, zero, one pattern splits the reflection into a pair of beams, as the grating picture predicts. And the nonperiodic zero, zero, one, zero, one, one sequence scatters the energy into multiple modest lobes, dropping the RCS in each. The point isn't that any one of these patterns is magical. It's that you get to choose among them in real time by changing bits, not by swapping hardware. Now comes the natural next step: two-bit coding. Instead of only two phase states, take four — zero, ninety degrees, one hundred eighty degrees, and two hundred seventy degrees. In digital terms, that's zero, zero, one; zero, one; one, zero; and one, one. Fabricationally, it's the same spirit as before: four patch sizes, each tuned to one of those quarter-cycle phase steps. Conceptually, this starts to look like you're drawing a phase ramp in coarse steps, which is exactly how you impose a steering angle. That's the generalized Snell's law in action: introduce a phase gradient along a surface, and a normally incident beam reflects at a predictable oblique angle. One of their sequences, a repeating zero, zero, zero, one, one, zero, one, one block, does just that. It's like a staircase that favors one direction. Why bother with four levels if two already do a lot? Bandwidth and control. The four-state lattice can shape the far field more gently, which buys you two things. First, cleaner steering — fewer unwanted sidelobes robbing your main beam. Second, broader RCS suppression when you're in diffusing mode. Their two-bit metasurface, built as a set of repeating lattices, showed monostatic reductions on the order of 20 decibels stretching from about 7.5 to 15 gigahertz. That's a wide chunk of spectrum held down by a coded pattern that looks almost like a gradient. And when you slice the three-dimensional scattering at representative frequencies, the energy stays smoothed out across angles rather than popping up as a few bright spikes. You lose less to chance resonances and gain more predictable behavior. Under the hood, the same tolerance themes reappear. Keeping a roughly half-cycle separation between adjacent phase states helps, but the design isn't brittle. The one-bit rule of thumb — hold the phase gap in the 145 to 215 degree window, and you'll still get at least a 10-decibel RCS cut — carries over in spirit. You also have more knobs now: which of the four states you place where, and how fast you step the phase along the surface. The cost is a modest one: you need more control complexity to address four states instead of two, whether that's four distinct unit cells in a static build or per-element electronics in a truly programmable platform. Let's pull the threads together. There are three big moves in this line of work. First, the conceptual shift: treat a metasurface like a field of pixels with discrete phase states. In one bit, it's a checkerboard you can flip; in two bits, it's a staircase you can sculpt. Second, the predictive backbone: a simple lattice-summation model where each cell contributes a known phase, and the far field is a weighted sum. That model explains why the zero, zero, zero, zero, zero, zero looks like a mirror, why the zero, one, zero, one, zero, one acts like a grating, and why a pseudo-random string pushes energy into many small lobes. Third, the hardware realization: a compact diode-based particle that toggles with a few volts, scaled into a thirty-by-thirty array under FPGA control, verified at a frequency where the two states are perfectly out of phase. There's a satisfying coherence to the numbers here. In static, printed one-bit surfaces, you get near-180-degree phase contrast across a band that spans multiple gigahertz, enough to see two exact oppositions within it. You can redirect or diffuse the beam with simple codes, and you can beat down the monostatic radar return by more than 20 decibels as the array grows. In the programmable build, you recover the same physics at 8.6 gigahertz, with the ability to flip among behaviors at will. And in two-bit coding, you extend the whole playbook — same principles, broader bandwidth, and finer control over where the energy goes. Why does this matter beyond the delight of turning waves into code? Because it's a roadmap for agility. If you can guarantee that your binary elements stay roughly out of phase, you get RCS reduction even when manufacturing or environment nudge the response. If your design doesn't care whether the lattice spacing is a bit tighter or looser — spanning from just over half a wavelength to triple — you can scale to new bands without reinventing the wheel. And if your controller is just an FPGA, you can switch functions on the fly: beam in, beam out, or blur into the noise. Cui, Qi, Wan, Zhao, and Cheng closed their study by pointing to higher frequencies — millimeter wave, even terahertz — where the same ideas can apply. The pieces are already there: patch libraries for the phase states, modeling that generalizes, and control electronics that get smaller and faster every year. The speculation window here is short. Imagine a future surface that can be a low-observable skin one second, a highly directive link the next, and a multipath scrambler after that — all by clocking out a new bitstream. In their hands, waves became code. And once that happens, it's hard to go back to a world where you must machine a new slab every time you want the field to do something different.

Not "digital" as a metaphor — literally coding the surface with bits. A unit cell that gives you a phase of zero becomes a zero. A unit cell that flips the phase by half a wavelength, or 180 degrees, becomes a one.

String those zeros and ones across a surface, and you don't just set an effective index. You program what the wave does.

Let's make that concrete. Start with the simplest case: one-bit coding. You have two kinds of square metallic patches on a dielectric — one plays the zero state, and the other the one.

The trick is to pick the patch sizes so their reflected phases stay almost exactly opposite over a broad band. In their static, printed design, the "zero" patch was wider than the "one" — roughly 4.8 millimeters versus 3.75 millimeters — and on that stack, the phase gap stayed near 180 degrees across about 8.1 to 12.7 gigahertz. It wandered between roughly 135 and 200 degrees, but the two elements aligned to a clean 180 at a couple of spots.

That's important. If your binary elements keep that phase opposition, the whole coding idea holds together, and you can treat the surface like a big, programmable diffraction grating.

Now, what happens when you start writing actual codes across that lattice? Here's the intuition: each cell contributes a phase, either zero or pi, and the far field is just the coherent sum of all those little contributions, like an array factor multiplied by an element pattern. Cui and colleagues wrote it down formally, but you don't need the equations to see the consequences.

If every cell is the same, all zeros or all ones, the surface behaves like a single, flat mirror and throws most of the energy back along one direction, mimicking a perfect magnetic conductor or a perfect electric conductor. If you alternate zeros and ones in a simple sequence, like zero, one, zero, one, zero, one, you build a grating and split the reflection into two symmetric beams. Mix the stripes — zero, one, zero, one, zero, one here, one, zero, one, zero, one, zero there — and you can pull four main beams.

The key is that you're not carving a new lens every time; you're just changing the pattern of bits.

There's more you can do when you let go of perfectly periodic codes. The team asked a radar question: can we spread out the reflections so no direction sees much energy? That's radar cross-section — RCS — reduction by diffusion.

With optimized one-bit sequences on an N by N lattice, they suppressed the monostatic RCS more and more as N grew. The headline number is this: by the time they got to N equals 20, the reduction was about 23.6 decibels compared with a flat reflector. And it wasn't one of those needle-thin, one-frequency tricks.

In the backward direction, the reduction stayed around 10 decibels across roughly 7.8 to 12 gigahertz. Two robustness checks matter here. First, the design kept working even when the phase gap between the zero and one elements drifted — anywhere from about 145 to 215 degrees still bought you at least 10 decibels of reduction.

Second, the spacing of the lattice relative to wavelength could swing a lot — from 0.6 to 3.0 — without spoiling the effect. That means you can scale or retune without breaking the core idea.

So far, this is a printed, static surface. But Cui's group wanted it to be alive. They built a reconfigurable particle — a tiny, symmetric metallic structure on a low-loss substrate with a single diode bridging the halves.

No bias, the diode is off, and the particle behaves like the zero element. Push a small direct-current voltage of 3.3 volts, and the diode turns on; the particle flips to the one state. In simulations, the phase difference between off and on sat near 180 degrees from about 8.3 to 8.9 gigahertz, and it nailed 180 at 8.6. Now you're not just printing a code. You're toggling it.

Arrange thirty by thirty of these particles into a metasurface, wire them so you can address columns, and give the whole array a brain — a field-programmable gate array or FPGA. In their demonstration, every five adjacent columns shared a control line, and the FPGA switched sequences on command. Four hard-coded patterns — zero, zero, zero, zero, zero, zero; one, one, one, one, one, one; zero, one, zero, one, zero, one; and zero, zero, one, zero, one, one — were loaded up like presets on a synthesizer.

Flip a switch, the FPGA streams out the voltages, the diodes go on or off, and the wave does something different.

At 8.6 gigahertz, the measurements line up with the codes you've just heard in your head. All zeros, all ones: a single, strong reflection, as if the surface decided to be a magnetic wall or an electric one. The alternating zero, one, zero, one, zero, one pattern splits the reflection into a pair of beams, as the grating picture predicts.

And the nonperiodic zero, zero, one, zero, one, one sequence scatters the energy into multiple modest lobes, dropping the RCS in each. The point isn't that any one of these patterns is magical. It's that you get to choose among them in real time by changing bits, not by swapping hardware.

Now comes the natural next step: two-bit coding. Instead of only two phase states, take four — zero, ninety degrees, one hundred eighty degrees, and two hundred seventy degrees. In digital terms, that's zero, zero, one; zero, one; one, zero; and one, one.

Fabricationally, it's the same spirit as before: four patch sizes, each tuned to one of those quarter-cycle phase steps. Conceptually, this starts to look like you're drawing a phase ramp in coarse steps, which is exactly how you impose a steering angle. That's the generalized Snell's law in action: introduce a phase gradient along a surface, and a normally incident beam reflects at a predictable oblique angle.

One of their sequences, a repeating zero, zero, zero, one, one, zero, one, one block, does just that. It's like a staircase that favors one direction.

Why bother with four levels if two already do a lot? Bandwidth and control. The four-state lattice can shape the far field more gently, which buys you two things.

First, cleaner steering — fewer unwanted sidelobes robbing your main beam. Second, broader RCS suppression when you're in diffusing mode. Their two-bit metasurface, built as a set of repeating lattices, showed monostatic reductions on the order of 20 decibels stretching from about 7.5 to 15 gigahertz.

That's a wide chunk of spectrum held down by a coded pattern that looks almost like a gradient. And when you slice the three-dimensional scattering at representative frequencies, the energy stays smoothed out across angles rather than popping up as a few bright spikes. You lose less to chance resonances and gain more predictable behavior.

Under the hood, the same tolerance themes reappear. Keeping a roughly half-cycle separation between adjacent phase states helps, but the design isn't brittle. The one-bit rule of thumb — hold the phase gap in the 145 to 215 degree window, and you'll still get at least a 10-decibel RCS cut — carries over in spirit.

You also have more knobs now: which of the four states you place where, and how fast you step the phase along the surface. The cost is a modest one: you need more control complexity to address four states instead of two, whether that's four distinct unit cells in a static build or per-element electronics in a truly programmable platform.

Let's pull the threads together. There are three big moves in this line of work. First, the conceptual shift: treat a metasurface like a field of pixels with discrete phase states.

In one bit, it's a checkerboard you can flip; in two bits, it's a staircase you can sculpt. Second, the predictive backbone: a simple lattice-summation model where each cell contributes a known phase, and the far field is a weighted sum. That model explains why the zero, zero, zero, zero, zero, zero looks like a mirror, why the zero, one, zero, one, zero, one acts like a grating, and why a pseudo-random string pushes energy into many small lobes.

Third, the hardware realization: a compact diode-based particle that toggles with a few volts, scaled into a thirty-by-thirty array under FPGA control, verified at a frequency where the two states are perfectly out of phase.

There's a satisfying coherence to the numbers here. In static, printed one-bit surfaces, you get near-180-degree phase contrast across a band that spans multiple gigahertz, enough to see two exact oppositions within it. You can redirect or diffuse the beam with simple codes, and you can beat down the monostatic radar return by more than 20 decibels as the array grows.

In the programmable build, you recover the same physics at 8.6 gigahertz, with the ability to flip among behaviors at will. And in two-bit coding, you extend the whole playbook — same principles, broader bandwidth, and finer control over where the energy goes.

Why does this matter beyond the delight of turning waves into code? Because it's a roadmap for agility. If you can guarantee that your binary elements stay roughly out of phase, you get RCS reduction even when manufacturing or environment nudge the response.

If your design doesn't care whether the lattice spacing is a bit tighter or looser — spanning from just over half a wavelength to triple — you can scale to new bands without reinventing the wheel. And if your controller is just an FPGA, you can switch functions on the fly: beam in, beam out, or blur into the noise.

Cui, Qi, Wan, Zhao, and Cheng closed their study by pointing to higher frequencies — millimeter wave, even terahertz — where the same ideas can apply. The pieces are already there: patch libraries for the phase states, modeling that generalizes, and control electronics that get smaller and faster every year. The speculation window here is short.

Imagine a future surface that can be a low-observable skin one second, a highly directive link the next, and a multipath scrambler after that — all by clocking out a new bitstream. In their hands, waves became code. And once that happens, it's hard to go back to a world where you must machine a new slab every time you want the field to do something different.

Related lectures