If you believe the only path forward for neural networks runs through backpropagation and its global error signal, the release of Deepity should give you pause. This is not a theoretical paper or a toy demonstration; it is an open-source, C++20 predictive coding engine that, on a laptop CPU, already matches and sometimes exceeds the accuracy of equivalent backprop networks while using a fundamentally different learning mechanism. The practical implication for anyone building or training models is immediate: there is now a real, performant alternative to the computational graph you have been told is unavoidable.
What makes this worth your attention is not the algorithm alone, but the engineering rigor behind it. The developer has hand-written AVX2 and AVX-512 SIMD kernels, integrated OpenBLAS and MKL for matrix operations, and built a CUDA backend that is still being tuned. The benchmark on a 784-512-512-10 sigmoid network tells a clear story: Deepity reached 98.21% accuracy in 487.5 seconds, outperforming both a JAX-based predictive coding implementation (97.55% in 531.4s) and a PyTorch backprop baseline (97.51% in 627.8s). These are not cherry-picked numbers from a cloud cluster; they come from a single 12th Gen i7 laptop, reproducible from the repository. This aligns with the kind of cross-platform consistency we have seen in other recent work, such as the Cross-platform AI compression that stays consistent across any hardware, where precision and reproducibility across different hardware became the central engineering challenge.
The deeper point is that predictive coding eliminates two major constraints of backprop: the need to store a backward computation graph and the requirement for weight-transpose operations during learning. Each layer only needs its own local prediction error and the top-down prediction from the layer above. This is not a marginal efficiency gain; it is a structural shift in how memory and compute scale with model depth. The developer has also made several PCN variants available, including a Direct Kolen-Pollack feedback option that reduces settling steps at some accuracy cost, and a "kitchen sink" network with toggles for residual connections and momentum settling. This modularity invites experimentation that backprop frameworks rarely offer. As we have seen in the From naive GEMM to FlashAttention: a free code-first GPU kernel series, the difference between a good idea and a useful tool often comes down to the quality of the kernel-level implementation. Deepity treats that implementation as a first-class concern.
The honest caveats matter here. This is alpha software, version 0.1.0a3, solo-maintained. The CUDA backend builds and runs but has not been validated for large-scale ImageNet training, and the convolution path uses im2col with cuBLAS rather than cuDNN's specialized kernels. The developer explicitly refuses to publish GPU numbers they have not validated. That restraint, in a field where benchmarks are often gamed, is itself a signal of competence. The specific detail to watch is whether the CUDA backend can close the gap with cuDNN for small-kernel convolutions, and whether the settling loop overhead becomes prohibitive at scale. If those challenges are solved, the barrier to adopting predictive coding for real-world workloads will drop significantly. For now, the CPU path is mature, the code is MIT-licensed, and the install is a single pip command. That is a low enough bar to justify a weekend experiment.