by changing
:If D<40 and getKey(1)
:20+D→U
:End
:If D≠0 and getKey(4)
:D-20→U
:End

to
:If D<40 and getKey(1)
:10+D→U
:End
:If D≠0 and getKey(4)
:D-10→U
:End

the code now scrolls vertically by 1. since the tilemap is half-byte compressed and there are 20 tiles per row of the map, that means there are 10 bytes in each row. so you only need to add 10 to scroll to the next row.

as for horizontal scrolling, that's a bit more challenging and may require changing the way you draw the tilemap. here's some modified code:
:.ATILMAP
:[11111111111111111111→GDB1      .Data Map size is 20 tiles (half-bytes aka nibbles) wide by 12 tiles high.
:[10001000000000000001           .The height of the displayed map is 8 tiles. this means the maximum
:[10000100000000000001           . vertical offset is 4 tiles. since each row is 20 tiles, the maximum vertical offset is 80.
:[10000001000000000001           . the width of the displayed map is 12 tiles. this means the maximum horizontal offset is
:[10000000001000000001           . 8 tiles.
:[10001000000000000001
:[10000010000000000001
:[10000000000000000001
:[10010000000000000001
:[10100000000000000001
:[10000000000000000101
:[11111111111111111111
:[55AA55AA55AA55AA→Pic1
:[FFFFFFFFFFFFFFFF
:0→S→D                       .OFFSETS - S = horizontal scroll, D= vertical scroll
:ClrDraw
:Repeat getKey(15)
:If D<80 and getKey(1)       .80 is the maximum vertical offset
:20+D→D:End
:If D≠0 and getKey(4)         .0 is the minimum vertical offset, naturally.
:D-20→D
:End
:S<8 and getKey(3)-(S≠0 and getKey(2))+S→S     .8 is the maximum horizontal offset
:For(Y,0,7
:For(X,0,11
:Pt-Off(X*8,Y*8,sub(GN,Y*20+X+D+S)*8+Pic1     .Y*20+X+D+S is a nibble in the tilemap
:End:End
:DispGraph
:End
:Lbl GN
:{r1/2+GDB1}→T                 .Divide the nibble by two to find the correct byte in the tilemap
If r1^2                        .If the byte in the tilemap isn't divisible by two
T^16:Else                      .Return the low nibble of the byte. Else
T/16:End                       .Return the high nibble of the byte.



not sure, but i think you'd just change DispGraph to DispGraph^r and have Pt-Off() be Pt-Off()^r

hmm.. i'm not very good with grayscale, but yes you're correct. you need two drawing commands. one that draws to the buffer, and one to the back-buffer. however, if you only want the black squares to be gray then you need to store the result of the sub(GN) call into a variable, and use an If conditional

yes. i seem to have it working except when you try to scroll, it starts flickering

edit: i found it out, though i'd like to see you get it on your own so i'm not going to post code (but i will later if you want me to)

Well, I fixed one problem.  Now the gray stays the whole time, but instead of being solid gray, it appears to have the checkerboard pattern behind it.

EDIT: Hmm...Well, If store the result of the call to GN in W, then W is either 0 or 1.  If its zero, then I want to write to the buffer, and I always write to the back-buffer.  However, it seems that the patterned tile is being written to the buffer over the whole tilemap.

EDIT 2: I have come to these possibilities:
            1) The GN call does not return 0 or 1 as I had supposed, therefore, the If conditional is always true, and always draws the patterned tile to the buffer
            2) The above statement is false, because the drawing command inside the if conditional wouldn't just draw the patterned tile,  and after looking at the code, GN does return 0 or 1.
            3) If #2 is true, then there shouldn't be anything wrong with that section of the code, and I messed up somewhere else.

GN does not explicitly return 1 or 0, it returns the half byte tile 0-F (0-15 in decimal).  Although personally, I don't like that routine since there is no X and Y its usage is confusing.

If you want a solid gameboy gray, you have to turn interrupts off for the entire code and you also need to make sure to adjust the pause time in between each DispGraph to the perfect amount.  It will take some tuning since every display is different unfortunately.  For me, I have a TI-84 Plus K-0108H and my perfect gray setting is this:

:FnOff
:Repeat getkey(15)
:
:Pause 7           ;Long pause
:For(A,0,15):End   ;Fine tuning
:
:DispGraphr
:End

By perfect, I mean like a gameboy, not even one of those slowly scanning lines that moves diagonally from one side to the other, I mean literal gray.  The pause times will of course have to be different depending on how much other code you have in your loop.

as a minor clarification, sub GN *does* return a 1 or a 0, since only 1's and 0's are in the tilemap.