The process is fairly simple:
Have 2 greyscale sprites
One Displays, then the other, in rapid succession.

easy code example:
[ffff0000ff00ff00]->Pic1F
[ff00ffff00ff00ff]->Pic1B
[ffffffff00000000]->Pic2F
[ffffff00ffff0000]->Pic2B
ClrDraw
ClrDrawr
repeat getkey(15)
Pt-Off(0,0,Pic1F)
Pt-Off(0,0,Pic1B)r
DispGraphrr
Pt-Off(0,0,Pic2F)
Pt-Off(0,0,Pic2B)r
DispGraphrr
End

It gives a very scanlined Grayscale, but the values go as follows:

(Value, 1st Pic Gray, 2nd Pic Gray, ranging 0-7 and 0-3 respectively)
0,0,0
1,1,0
2,1,1 (2,0 looks the same, but is more flickery)
3,0,3
4,1,2
5,1,3
6,2,3
7,3,3

Simple process. Some optimization (or Asm rewrites for built-in commands, dispgraphrrr anyone? ) and it could be rather smooth! On my nspire, they're all quite flickery, but I got to try it for a tiny bit on an 83+, and it looked much better. I had not yet tested all the shades, though.

I'm not sure exactly how close a few (3 and 4, among others) are in shade, since the nspire sucks at greyscale

I tried with 4-level and 3-level once (would have had smoother shades) but the timings didn't work out, and it ended up just being solid 3-level.

Hey, it's their emu that sucks at not seeing greyscale images and using their hardware-driven stuff.

Huh, I couldn't get it to work really on my 84+ I checked my code twice but all I'm getting is two solid lines of black, a row of alternating black and gray pixels, two rows of that last row reversed, two rows of gray, and one row of alternating gray and blank pixels So I don't know why it's not working for me But seems like a cool idea/program.

You should post a 8xp or something, I would like to see how this looks like

EDIT: Nvm I just copied it on calc. Seems nice, but if I fill the entire screen with sprites it looks really crappy. It might be ok for games with very few sprites displayed in 15 MHz mode, but it might be unpractical otherwise.

Can you tell me if this code works.
[ffff0000ff00ff00]->Pic1F
[ffffffff00000000]
[ff00ffff00ff00ff]->Pic1B
[ffffff00ffff0000]
ClrDraw
ClrDrawr
0=>A
repeat getkey(15)
1-A=>A
Pt-Off(0,0,A*8+Pic1F)
Pt-Off(0,0,A*8+Pic1B)r
DispGraphrr
End


DJ: This was intended to make a few things on the screen higher level (like characters) while the rest is still 4 level.

That appears to be swapping between the two sprites, and optimizing the code, by having a go 1,0,1,0, but why not use not(a->a?

also, does ++ no longer work?

An exemple of code to see 8 level grayscales :
:.GRAY8
:[0000000000000000→Pic1
:[FFFFFFFFFFFFFFFF]
:0→A→B→C
:Repeat getKey(15)
:sub(GR)
:DispGraph<sup>r</sup><sup>r</sup>
:End
:Return
:
:Lbl GR
:ClrDraw
:ClrDraw<sup>r</sup>
:1-C→C
:For(Y,0,7)
:For(X,0,11)
:If X+1^2+C
:If 1-A→A
:1-B→B
:End
:End
:Pt-Off(X*8,Y*8,B*8+Pic1)
:Pt-Off(X*8,Y*8,A*8+Pic1)<sup>r</sup>
:End
:EndTop left, there is in order:
black and black, black and gray 75%, gray 75% and gray 25%, gray 75% and white, gray 25% and black, gray 25% and gray 75%, white and gray 25%, white and white.
B change buffer and A back-buffer. C alternates between two screens imaginary.

Actually there is only 7 grayscale (gray 75% and gray 25% = gray 25% and gray 75%).

EDIT : Woa, it work perfectly with full mode.