What if the next edge-AI accelerator didn't just consume energy—but harvested part of the energy it needed from the environment?
That question is the starting point of SOLACE: a conceptual architecture that combines integrated photovoltaics, optical neural networks, and low-power CMOS into a single energy-aware computing system.
This is not a claim that we have already built a self-powered AI chip.
It is a research direction—and an attempt to ask a much more interesting question:
Under what conditions can ambient light meaningfully offset the energy cost of AI inference?
The Core Idea
SOLACE is based on three tightly coupled layers:
AMBIENT LIGHT
│
▼
┌─────────────────────┐
│ SPECTRAL PV LAYER │
│ │
│ Visible → Harvest │
│ NIR → Transmission │
└──────────┬──────────┘
│
Harvested Energy
│
▼
┌──────────────┐
│ Energy Buffer│
│ + PMIC │
└──────┬───────┘
│
┌─────────────────┴─────────────────┐
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ Photonic Neural │ │ CMOS Substrate │
│ Network │◄────────────►│ │
│ │ │ SRAM │
│ Optical MAC │ │ ADC │
│ Phase Elements │ │ Control │
│ WDM / Diffractive│ │ Power Management │
└────────┬─────────┘ └──────────────────┘
│
▼
Photodetector
│
▼
ADC
│
▼
Digital Output
The architecture is deliberately hybrid.
Photonics does what photons are good at.
CMOS does what CMOS is good at.
PV supplies whatever energy the environment can realistically provide.
Why Photonics?
Modern neural networks perform enormous numbers of linear operations.
At a high level:
$$
y = Wx
$$
Optical systems can implement certain matrix-vector operations through propagation, interference, modulation, diffraction, or programmable photonic structures.
The attraction is obvious:
- massive parallelism
- high bandwidth
- potentially low latency
- reduced data movement for certain workloads
- natural support for wavelength multiplexing
But there is a catch.
The optical computation itself is only one part of the system.
The real energy equation looks more like:
$$
E_{inference} =
E_{laser}
+
E_{modulator}
+
E_{optical}
+
E_{detector}
+
E_{ADC}
+
E_{SRAM}
+
E_{control}
+
E_{power}
$$
And this is where many futuristic photonic-AI claims become questionable.
A photonic MAC can be extremely efficient while the system surrounding it is not.
SOLACE is designed around this problem.
The Real Enemy: Domain Conversion
Imagine an optical neural network performing an enormous matrix multiplication almost for free.
Sounds incredible.
Now add:
electrical → optical
then:
optical → electrical
then:
analog → digital
then:
memory access
then:
control
then:
power conversion
Suddenly, the energy advantage can look very different.
This is why SOLACE treats optoelectronic conversion as a first-class design variable rather than an implementation detail.
The key question becomes:
Does the energy saved by optical computation remain after the complete inference pipeline is included?
A Spectrally Selective Solar Layer
The PV layer introduces another unusual idea.
Instead of asking the photovoltaic layer to absorb everything, SOLACE asks:
Can we selectively harvest one part of the spectrum while allowing another part to reach the photonic computing layer?
Conceptually:
Ambient Spectrum
│
┌──────────┴──────────┐
│ │
Visible NIR
│ │
▼ ▼
Harvest Transmit
│ │
▼ ▼
PV Photonic Core
For example, the architecture could investigate optical computing around wavelengths such as:
- 850 nm
- 980 nm
- 1064 nm
while using other portions of the spectrum for energy harvesting.
This creates a new co-design problem:
$$
\text{PV spectrum}
\leftrightarrow
\text{Optical computing spectrum}
$$
The PV and photonic layers can no longer be designed independently.
But Can Ambient Light Actually Power AI?
This is where SOLACE becomes much more interesting.
Let's use a deliberately conservative conceptual example.
Suppose:
$$
A=1\,cm^2
$$
and indoor/environmental irradiance is around:
$$
1.5\,W/m^2
$$
with an effective PV efficiency of:
$$
18\%
$$
Then:
$$
P_{PV}
1.5
\times
10^{-4}
\times
0.18
$$
which gives approximately:
$$
27\,\mu W
$$
That is not a lot of power.
And this immediately destroys one tempting interpretation of SOLACE:
Ambient light is not a magic replacement for a battery or power supply.
For example, if a hypothetical inference consumes:
$$
100\,\mu J
$$
then harvesting 27 μW requires approximately:
$$
T =
\frac{100\,\mu J}{27\,\mu W}
\approx3.7s
$$
to accumulate enough energy for one inference.
That's obviously not 30-FPS computer vision.
But it could be extremely interesting for:
- event-driven vision
- autonomous sensors
- environmental monitoring
- industrial sensing
- intermittent inference
- battery-constrained IoT
- wake-on-event AI
And that changes the entire design philosophy.
SOLACE Is Not "Self-Powered AI"
The more scientifically defensible description is:
Ambient-light-assisted, duty-cycled photonic edge AI.
The system stores harvested energy in an energy buffer:
Ambient Light
│
▼
PV
│
▼
Energy Buffer
│
├── Energy available?
│ │
│ YES
│ ▼
│ Run inference
│
└── NO → Continue harvesting
Inference becomes energy-aware.
The accelerator doesn't simply ask:
"Do I have an input?"
It asks:
"Do I have enough energy to process this input?"
That opens an entirely different research direction.
The SOLACE Energy Equation
A useful system-level model is:
$$
E_{total}
E_{source}
+
E_{mod}
+
E_{loss}
+
E_{det}
+
E_{ADC}
+
E_{SRAM}
+
E_{control}
+
E_{PM}
$$
Meanwhile:
$$
E_{harvested}
P_{PV}T_{harvest}
$$
and the most important metric becomes:
$$
R_{self}
\frac{E_{harvested}}
{E_{total}}
$$
If:
$$
R_{self}\ge1
$$
the system can theoretically sustain its workload over the defined harvesting interval.
If:
$$
R_{self}<1
$$
the PV is still useful if it reduces the external energy requirement.
That distinction matters.
And Then There Is the Laser
One of the easiest mistakes in optical computing is confusing optical energy with electrical energy consumed by the optical source.
If:
$$
P_{opt}=1mW
$$
and the wall-plug efficiency is:
$$
\eta_{WP}=20\%
$$
then:
$$
P_{electrical}
\frac{1mW}{0.2}
5mW
$$
The system doesn't magically consume 1 mW.
It consumes 5 mW at the source.
And that is before considering:
- coupling loss
- propagation loss
- scattering
- absorption
- detector inefficiency
- modulator power
- thermal stabilization
This is why SOLACE evaluates the entire energy chain, not just optical arithmetic.
Noise Is Part of the Architecture
An optical neural network isn't operating in an ideal mathematical universe.
The model must account for:
Shot noise
$$
i_{shot}^2=2qIB
$$
Detector noise
$$
\sigma^2_{det}
$$
Quantization noise
$$
\sigma^2_{quant}
$$
Phase errors
$$
\phi_i=\phi_i^*+\epsilon_i
$$
Optical loss
$$
\eta_{opt}
\eta_{coupling}
\eta_{prop}
\eta_{scatter}
\eta_{absorption}
$$
The final question isn't:
"Can photons multiply matrices?"
They obviously can perform useful linear transformations.
The real question is:
Can they do it accurately enough, with sufficiently low total system energy, after every physical imperfection is included?
CMOS Doesn't Disappear
SOLACE is not trying to eliminate CMOS.
That would be unrealistic.
CMOS remains responsible for:
- control
- scheduling
- SRAM
- ADC
- preprocessing
- nonlinear activation
- post-processing
- communication
- power management
- system coordination
The architecture is therefore:
$$
\boxed{
Photonic\ Linear\ Algebra
+
CMOS\ Intelligence
}
$$
rather than:
$$
Photonic\ Everything
$$
This hybrid approach is much more realistic.
Why 2.5D First?
A monolithic:
PV + Photonics + CMOS
chip is an exciting long-term objective.
But it should not be the first prototype.
A more realistic path is:
┌────────────────────┐
│ PV Die │
├────────────────────┤
│ Photonic Die │
├────────────────────┤
│ CMOS Die │
├────────────────────┤
│ Energy Management │
└────────────────────┘
A hybrid or 2.5D architecture provides more freedom to optimize each technology independently.
Only after the individual technologies mature does monolithic integration become a realistic target.
The Perovskite Problem
Perovskites are extremely interesting for this concept, particularly for low-light harvesting.
But they are not magic materials.
The research must confront:
- degradation
- moisture sensitivity
- thermal instability
- ion migration
- spectral mismatch
- manufacturing yield
- encapsulation
- lead toxicity
The central question isn't:
"Can perovskite PV reach high efficiency?"
It is:
Can it maintain useful low-light power output, stability, spectral selectivity and manufacturing compatibility while integrated with a photonic/CMOS system?
That's a much harder problem.
The Benchmark Must Be Brutally Fair
SOLACE shouldn't be compared against an accelerator using random TOPS numbers.
A fair comparison needs identical:
- workload
- model
- batch size
- precision
- accuracy target
- preprocessing
- postprocessing
- latency definition
- power measurement boundary
Potential baselines include:
- Google Coral Edge TPU
- NVIDIA Jetson Nano
- IBM NorthPole
- conventional CMOS edge accelerators
For example, Google Coral's Edge TPU is specified at 4 TOPS for 8-bit operations and 2 TOPS/W.
IBM NorthPole represents a very different philosophy, emphasizing distributed on-chip SRAM and data locality rather than simply maximizing raw arithmetic throughput.
The goal is not to claim that SOLACE beats these systems today.
It doesn't.
The goal is to determine whether a future SOLACE implementation could occupy a useful point in the energy–latency–accuracy design space.
The Experimental Roadmap
The project can be developed without immediately attempting an impossible three-layer chip.
Phase 1 — Software
Build a digital twin of SOLACE.
Test:
- MNIST
- Fashion-MNIST
- CIFAR-10
- CIFAR-100
- Tiny-ImageNet
Inject:
- optical noise
- phase errors
- quantization
- detector noise
- coupling loss
Phase 2 — Optical Prototype
Build:
Laser
↓
Modulator / SLM
↓
Diffractive Optical Network
↓
Photodetector
Measure real:
- optical loss
- SNR
- latency
- energy
- accuracy
Phase 3 — PV Characterization
Test the energy layer under:
- indoor LED lighting
- sunlight
- low-light conditions
- different spectra
- different temperatures
Phase 4 — Hybrid Integration
Combine:
PV
+
Photonic accelerator
+
CMOS controller
+
Energy buffer
Phase 5 — End-to-End Demonstration
Finally:
Light
↓
PV
↓
Energy Buffer
↓
AI Inference
↓
Prediction
And measure everything.
Not estimated.
Measured.
The Most Important Experiment
The most interesting experiment isn't:
"How fast is the optical neural network?"
It is:
How much of the total energy required for a real inference can the environment supply?
That produces a much more meaningful metric:
$$
\boxed{
Energy\ Self\ Sufficiency
\frac{Harvested\ Energy}
{Total\ Inference\ Energy}
}
$$
And it should be measured over realistic workloads and duty cycles.
Monte Carlo Instead of Marketing Numbers
Rather than reporting one spectacular number, SOLACE should report distributions.
Randomize:
- irradiance
- PV efficiency
- optical coupling
- detector responsivity
- wall-plug efficiency
- ADC energy
- SRAM energy
- phase error
- PMIC efficiency
- ambient spectrum
Then run:
$$
N=10,000
$$
simulations.
The result becomes:
Probability of:
Accuracy > target
Energy < target
Power < budget
Self-sufficiency > 1
That's much more useful than claiming:
"1000× more efficient."
What Would Count as Success?
Success does not necessarily mean powering continuous video from indoor light.
A much more realistic success criterion would be something like:
SOLACE demonstrates statistically significant system-level energy reduction for a defined low-precision edge-AI workload while ambient harvesting supplies a measurable fraction of the average energy budget.
That would already be a meaningful result.
The Bigger Idea
The deeper concept behind SOLACE is not simply:
"Put a solar cell on an AI chip."
It is:
Design the computing architecture around the energy available in its environment.
Today we generally design:
$$
Compute \rightarrow Power\ Supply
$$
SOLACE asks whether we can design:
$$
Environment
\rightarrow
Energy
\rightarrow
Computation
\rightarrow
Workload
$$
with the workload itself adapting to energy availability.
That leads toward a different class of AI systems:
Energy-Adaptive Intelligence
Systems that can dynamically decide:
- when to compute
- how much to compute
- at what precision
- which optical path to use
- when to sleep
- when to harvest
- when to transmit
based on their available energy budget.
The Long-Term Vision
A possible future SOLACE system could look like this:
ENVIRONMENT
│
┌───────────┴───────────┐
│ │
LIGHT SIGNAL
│ │
▼ ▼
┌───────┐ ┌─────────┐
│ PV │ │ Sensors │
└───┬───┘ └────┬────┘
│ │
▼ ▼
Energy Buffer AI Workload
│ │
└──────────┬────────────┘
▼
ENERGY-AWARE
AI SCHEDULER
│
┌───────┴───────┐
▼ ▼
PHOTONIC CMOS
COMPUTE COMPUTE
│ │
└───────┬───────┘
▼
DECISION
The accelerator doesn't simply calculate.
It negotiates with its environment.
SOLACE Is a Hypothesis, Not a Finished Chip
That's an important distinction.
SOLACE currently represents a research architecture, not a fabricated processor.
The interesting work now is to find its actual operating boundary.
Maybe the experiments will show that:
- PV contributes 1%
- or 10%
- or 50%
- or, under specific duty cycles, more than 100% of the average energy requirement.
The answer should come from physics and measurement—not marketing.
And if the experiments demonstrate that ADC energy dominates everything else, that is not failure.
That's a research result.
If optical losses dominate, that's a research result.
If ambient harvesting only becomes meaningful below a certain duty cycle, that's a research result.
The goal is to discover where the architecture actually works.
Final Thought
The next generation of edge AI may not be defined simply by:
TOPS
or:
TOPS/W
It may be defined by something more fundamental:
$$
\boxed{
\textbf{How much intelligence can a system sustain with the energy available around it?}
}
$$
SOLACE is an attempt to explore that question at the intersection of:
Photonic Computing × Edge AI × Energy Harvesting × Semiconductor Architecture
Not a claim that physics has already been conquered.
A proposal to find out where physics draws the line.
Research Direction
SOLACE — Energy-Harvesting-Assisted Photonic Edge AI
Concept:
PV + Optical Neural Network + CMOS + Energy-Aware Scheduling
Potential first benchmarks:
MNIST → Fashion-MNIST → CIFAR-10 → Tiny-ImageNet
Potential first implementation:
Hybrid / 2.5D integration
Long-term objective:
Highly integrated photonic–CMOS–PV intelligence
The interesting question is no longer:
Can we build an AI accelerator that consumes less energy?
It is:
Can we build an AI accelerator that learns to compute according to the energy available in its environment?
That is the problem SOLACE is designed to investigate.
created by Seyed Alireza Alhosseini Almodarresieh
Top comments (0)