The 5th generation project found that Prolog isn't very parallelizable and thus they created a language called KL1 which was more parallelizable than Prolog but not as good in other ways.

There were a few nearly identical parallelizations of Prolog. Besides KL1, there were Concurrent Prolog, GHC, Paralog, Strand, and Aldwych. The structure of Prolog-like concurrent systems is like the Actor model, based on message passing, and shares the problem of indeterminacy in the ordering of messages. These systems had to drop backtracking, because that requires access to a global stack.

In the end, it proved difficult to implement clause invocation in these languages as efficiently as procedure invocation in object-oriented programming languages. The combination of efficient inheritance-based procedure invocation together with class libraries and browsers was better than the slower pattern-directed clause invocation of the FGCS programming languages, so concurrent object-oriented message-passing languages like Java and C# became the mainstream.

I would suggest that the relational database approach is simpler and about as powerful as the rule-based approach to knowledge processing. From a practical point of view, any row of a Relatonal DataBase System table can be considered as a rule, provided that at least one attribute has been selected as an output.

I agree, along with a huge range of parallel machines.

Parallel machines weren't a great idea in the early 90s, because you could barely get one decent CPU on a chip and adding memory turned it into a large board per core. Now you can have satisfying numbers of CPUs plus memory on a single chip, and even a useful prototype on an FPGA.