I wonder if there is a good design, in order to bring more third-party nodes into the system like this, but in a more flexible manner.
As for example the Pizza node is quite awesome to be shared here and there, however a hardcoded implementation into the core architectural domain of Blender, is bit more tricky and complex. As for example adding too many custom nodes eventually can lead to lots of maintainance where you would have to patch and update everything within each new Blender release.
Is feasible in terms of architectural implementation to strike a good balance between keeping the core architecture clean of your own modifications and then any additional third-party nodes added on top of the rest as treated as extension features rather than core features.
With this mindset, say for example you have only a master node, that can only load compiled DLLs from the filesystem and then export vertices/indices and any other sort of such data.
The DLL can only return a data structure like:
int* verts; int numverts; int* indices; numindices and the implementation is sandboxed (pure implementation without external dependencies).
So no more no less with this mindset you can introduce only one node into the core architecture and then have a number of other nodes provided externally.
To see where I am going with this, have a peek on github about After Effects plugins, and you can see that you can bring any custom pixel effect into the system on the fly. This is something I am thinking about doing with Blender and let at least the core be rock solid and stable, but any other experimental or use-throw usecase be treated as an extension.
I am very interested to try these ideas. But still I am not sure about the best approach, I will have look at it in more detail first and then say where to draw the lines.