Currently, UML implements a uniprocessor virtual machine. The only barrier to enabling SMP is making the UML architecture layer SMP safe. Virtual SMP involves letting UML have one process per virtual processor runnable on the host at a a time. This is done by starting one idle thread per processor and then letting them schedule normally.
Once SMP is working, a number of interesting possibilities open up. Obviously, this would allow developers to do SMP development without needing access to SMP hardware. It would also allow developers who have SMP hardware to test kernels on more processors than they have.
It would also allow more exotic hardware to be simulated. This is especially interesting for cluster hardware. The cluster topology and other features could be emulated with UML, allowing support to be done by people without access to the hardware.
Another interesting possibility is running a single UML instance across multiple physical hosts. This would be done by partitioning the UML physical memory between the nodes, and faulting those pages from node to node as needed. This can be done with a fairly simple change to the memory fault handler. It would keep track of what pages are resident on the current node, and when a fault occurred on a non-resident physical page, it would ask the node that owned it for the data. That other node would unmap it and pass the data over, where it would be copied in and mapped in to the physical memory area on that node.
This is an extreme example of NUMA, and it won't perform at all well until Linux has pretty good NUMA support. On the other hand, this would provide a simulated NUMA platform to anyone running Linux, so it would potentially bring a lot more talent to bear on the problem of NUMA support, which could make it reality more quickly.