Learn
What a field-programmable analog array is, how it differs from the digital chips you already know, and how you go from a drawing to programmed silicon with Varquon.
A field-programmable analog array (FPAA) is to analog circuits what an FPGA is to digital logic: a single chip of reconfigurable building blocks that you wire together in software instead of on a breadboard or a new PCB.
Traditionally, every analog circuit — a filter, an amplifier, a sensor front-end — is a fixed arrangement of transistors, resistors and capacitors. Change the design and you re-route a board or re-spin silicon, a cycle that takes weeks to months. An FPAA collapses that loop: the analog primitives already exist on the die, connected through a programmable switch matrix, so "building" a circuit means choosing which blocks connect to which.
Push a new configuration and the chip becomes a different analog circuit in well under a second. You iterate on real hardware as fast as you edit a schematic — no soldering iron, no fab queue.
Want to feel it? The in-browser playground lets you tweak real example circuits and watch the waveform change live.
All three let you implement signal-processing systems without custom silicon. The difference is where the signal lives while you work on it.
| FPAA | FPGA | DSP / MCU | |
|---|---|---|---|
| Domain | Continuous analog | Digital logic | Digital (software) |
| Signal stays | Analog end-to-end | Sampled / quantised | Sampled / quantised |
| You design in | Schematic of analog blocks | HDL / logic | C / firmware |
| Latency | Continuous, no clock | Clock-bound | Sample-rate bound |
| Best at | Front-ends, filters, control, ultra-low-power sensing | Parallel digital, high throughput | Complex math, flexibility |
| Power for continuous analog | Very low | Higher | Higher (must keep sampling) |
FPAAs shine right where the real world meets your system: conditioning and filtering sensor signals, closing fast control loops, and doing always-on analog computation at a fraction of the power of an equivalent digital pipeline — often before a signal is ever converted to bits.
With Varquon, the loop from idea to programmed chip is a familiar, FPGA-style flow inside one desktop app — CYGVEUM.
Place analog blocks on the schematic canvas and wire them together. Group sub-circuits into reusable hierarchical symbols.
CYGVEUM maps your schematic onto the device's switch matrix, producing a
switch list — the exact set of on-chip connections that realise
your circuit (written to output/switches.txt and a programming
out.hex).
Connect a board over USB and load the configuration onto the chip. The fabric reconfigures and your circuit is live.
Probe nodes, tweak the design, recompile, reprogram — no recompiling silicon, no rebuilding a board.
See the step-by-step version, with the example projects, in the CYGVEUM getting-started guide.
Under the hood, an FPAA is a grid of analog primitives connected by a crossbar of switches. The compiler's job is to close exactly the switches that wire your chosen primitives into the circuit you drew.
The current Varquon part, the VRQ-X1, is a proof-of-concept: a compact test chip whose crossbar routes a small set of transistor-level primitives — a handful of NMOS and PMOS devices and on-chip resistors, plus supply, ground and external pins. It's deliberately small, but it's the whole flow working end-to-end on real silicon: draw a CMOS inverter or an RC filter, compile it to a switch list, program it, measure it.
That's exactly what the example circuits demonstrate — and what you can poke at in the example gallery.
The proof-of-concept proves the loop; the roadmap scales it. The flagship VRQ-X8 moves from a handful of primitives to hundreds of higher-level, individually tunable analog blocks — op-amps, OTAs, filters, integrators, multipliers and comparators — so you compose at the function level, not just the transistor level.
The design flow stays the same — the canvas just gets a much bigger box of parts.
Three good next steps: