USB flash drives are slower to use than flash. Though if you're wanting to emulate the i386, I'm not sure it really matters, as it is already far faster to begin with An interesting demonstration, though!

Reminds me of CalcDOS - an x86 Emulator. (Only linked for grins and giggles, as the program isn't very functional.)
I think it's an interesting general question what old hardware we can readily emulate on the 83+ series. I don't know enough to suggest any candidates, but I'm sure something interesting could be done. 15MHz is relatively powerful. Even the 83+'s 6.

The OP "registers" are a set of memory areas that are used as operands by the OS's floating point routines. Unless you need floating point, there shouldn't be a need to explicitly deal with them.
If you want to do math with larger integers, you basically need to write the routines yourself (precluding a library/axiom already having been written. I don't follow Axe too much.).
For example, to add the number BA (formed from variables A and B) to DC, and store the result back to BA, you could do something like A+C->A<C+B+D->B, where -> is the STO> symbol.
An easier-to-follow variation goes like this:
A+C->A
If A<C
B+D->B
Else
B+D+1->B
End

The "fancy GetCalc statement" calculates the corresponding address in the original. So yes, it can be used to update in the original, and you can also update in the running copy. There shouldn't be a need to always keep the two in sync, though.
I'm not sure how this works when running from a shell. I'm under the impression that most shells will copy (from Archive) or move (from RAM) the program to the appropriate location, and this would yield the program's (or the copy's, if from Archive) name in OP1. Thus, it will just update in-place. However, I'm not sure if this is documented, so unless you can confirm it in Ion, MirageOS, DoorsCS, etc., it would be best not to have code like Deep's in shell versions.

When the TI-OS runs an ASM program, it copies it to $9D95 and deletes the copy when it's done. Thus, any changes to the running copy don't do anything. What Deep's code does is find the original program (not the running copy) and get the address of the high score from there.
Note that this has the possibility of not working as intended when running from a shell.
If you're curious how Deep's code works, here's a quick outline:
GetCalc( takes the address of a string with a variable name and returns the address of the variable's data. When the TI-OS runs a program, the name of the program is copied to OP1, whose address is $8478. GDB3-_E9D93 is the offset to the high-score value from the start of the ASM program header. This is added to the address given by GetCalc(, and the sum is the location of the high-score value in the original copy of the program.

I'm posting on behalf of HavokDelt on IRC, who doesn't currently have access to a GUI to be able to post. I'm going to pretend it's my problem for easier reading.
So, I want to create a slider that will draw the normal line to a parametric curve at a given time.
My current setup is this: a and b are y and x for the parametric curve, and are defined in terms of t. The variable y and x themselves represent the line. byx represents the slope of the tangent line, calculated as "da/dt*(db/dt)^-1". So, the line is "y=a+byx^-1*(x-b)".
The problem is this: while byx gives the expression for the derivative just fine when t is not defined, when the slider is in use t is given a numeric value. Because of that, a and b are no longer expressions, but values, so da/dt and db/dt are both 0, and byx is undefined.
Now, another calculator I have has an Exchange function that replaces one variable with another, say t with k, and I can use it to make a similar thing work there.
But how can I do this on the Nspire?

If exactly one number will be zero and the numbers aren't sorted in any way, I'm pretty sure the best way is to go through them with a variable containing the minimum value, while ignoring zeroes.
Here, for example, is some code that will give the minimum non-zero value in the first 100 bytes of L₁ in M (And -1 if they're all 0):
-1->M
L1->X
For(100
If ({X}->V<M)?V=/=0
V->M
End
X++
EndThere's probably a more optimized way to write that, but it should work.
If there could be more than one zero, the essence of what you have to do is have a flag that records whether you've already encountered one zero.
Edit: Runer112 wins by far. The method I've proposed would work better across lots of values (perhaps at least 10) than across 4.