The good news is Psymeric now supports complex numbers and inplace addition and complex numbers (Complex32 and Complex64). Also by doing some tuning, I got the overhead of Psymeric down to less than three times that of Numeric (versus 20 times in the version of Numarray that I have). Even without Psyco, the code only has overhead of five and half times that of Numeric, so it seems that the Numarray folks should at least be able to get down to that level without throwing everything into C. I have not been able to increase the asymptoptic speed and I think I'm probably stuck on that front for the time being. For the most part Psymeric is close to Numeric for large arrays, which makes it about 50% faster than numarray for noncontiguous and half as fast for contiguous arrays. These timings are for Float64: for Int8, Psymeric is ~3x slower than Numeric and for Int16 it's 50% slower, for Int32 2x slower. Psymeric is very slow for Float32 and Complex32 (~10x slower than Numeric) beacause of some Psyco issues with array.arrays and floats which I expect will be fixed at some point. And finally, for Complex64, psymeric is comparable to Numeric for addition and subtraction, but almost half as fast for multiplication and almost a third as fast for division. Barring some further improvements in Psyco or some new insights on my part, this is probably as far as I'll go with this. At this point, it would probably not be hard to make this into a work alike for Numeric or Numarray (excluding the various extension modules: FFT and the like). The one relatively hard part still outstanding it ufunc.accumulate/reduce. However, the performance while very impressive for an essentially pure python solution is not good enough to motivate me to use this in preference to Numeric. If anyone is interested in looking at the code, I'd be happy to send it to them. Regards, -tim