FPGAs, or field-programmable gate arrays, are reconfigurable devices commercially available on the market today. With them people can create custom circuitry to meet specific needs.
	An FPGA sounds somewhat like the cell matrix: reconfigurable hardware you can customize. So what is the difference? What does a cell matrix do that an FPGA can't?

	onboard differentiation: On an FPGA, you can lay down circuits, but you cannot lay down circuits that build other circuits. On a cell matrix, you can do both.
	self-configurability: A cell matrix is able to analyze and modify its own circuits. This means the control circuitry can be modified and improved over time, leading to more versatile designs. With an FPGA, the external control circuitry is fixed.
	configuration speed: The circuitry within a cell matrix can be configured and reconfigured in parallel. Since larger matrices also contain more configuration controllers, larger matrices can be configured as efficiently as smaller ones. With an FPGA, larger gate arrays require more time to configure than smaller ones.
	partial configuration: In a cell matrix, one section of the matrix can be configured independently of the rest of the matrix. With most FPGAs, the entire gate array must be configured to change any section of it.
	fault tolerance: It is the software, not the hardware, that distinguishes regions of the cell matrix. The architecture supports software-controlled fault tolerance. The monitoring of the entire matrix for faults is also feasible, because it can be done in parallel.
	scalability: When you need more computing power, you can connect two matrices together to form a larger one. You need not make any modifications to their internal structure, nor do you need additional hardware to resolve addresses between the two matrices; you simply connect them along their edges. With two FPGAs, you have the problem of two distinct address spaces.      Moreover, due to this regularity in its structure, the cell matrix also scales up perfectly to extremely high transistor counts. This is a critical design feature in terms of implementation in future atomic-scale technologies such as nanotechnology and molelectronics. The ability to pack cell matrix cells into atomic-scale computers will be extremely important in the future. FPGAs have a more complex, less replicatable architecture, and can not as easily be scaled up.
	potential for low cost manufacturing: As a general rule of thumb, it's cheaper to make one thing over and over again than it is to make multiple distinct things. The cell matrix hardware never changes; only the software changes. The cells themselves are identical. When atom-level circuit building becomes feasible, the identical structure of matrix cells and their interconnections will lend itself nicely to such techniques.
	tolerance of manufacturing defects: The software can probe for faulty cells or regions and simply work around them, similar to how bad regions in hard disk drives are detected and mapped around. This means imperfectly-manufactured matrices need not be thrown out. Purity could be assigned to manufactured lots as it has is for plywood and other products, and the prices set accordingly. This is an important feature when one considers future devices with a trillion trillion elements in a single package (which, statistically, are almost certain to contain faults).

Summary: A cell matrix can be used as an FPGA, but it can also be used in a lot of other applications as well because of its additional capabilities. Like an FPGA, the cell matrix is a reconfigurable hardware platform. It is a collection of cells, each of which can be configured to perform a different input-to-output mapping. Unlike an FPGA, the cell matrix is self-configurable, configurable in parallel or in part, fault tolerant, scalable, and potentially cheaper to manufacture. The cell matrix is a more appropriate architecture for nanotechnology and other molecular-level manufacture of electronic devices.