Well, TI-Boy doesn't convert anything other than simply bundling the ROM into an app with the emulator code.

Also, the majorly major problem with this is that it will be quite hard to tell whether an immediate value is a pointer, an offset, or just an integer, and it will also be tough to follow variable jumps when parsing a program (such as PUSH followed by RET or JP HL)

calc84 has clearly said in his ti-boy project thread that it's an emulator, not a convertor. The main problem with a convertor is finding the difference between data and code. If you convert data, or leave parts of code untouched, you may have some nasty results. One way of doing this would be to create a very simple 'emulator', that starts reading the program from it's start, and that knows which sequences of bytes represents jumps, calls (and ret's) and bcalls. Also code in the size of optcodes so that it won't recougnize a jump or bcall in what is actually just the end of one optcode and the beginning of an other one. Then you need a boolean array. Use one boolean for every byte of the program. These should all be false at start and mark if a byte is read. Then, 'emulate' the program. At every byte you pass, mark the byte as read (set boolean to 'true'). When you encounter a call instruction, push the position of that instruction to a stack, and continue emulating from where the call points to (substract $9D93 from the label behind the call to get the number of bytes from the start of the program). When you encounter a ret instruction, continue emulating from the location in the stack, or if the stack is empty, stop the emulation. When you come across a jump instruction, check if it's conditional or not. If conditional, save it's location to an other stack than the one used by calls. Then just continue emulating from the location the jump points too, just as you would do with normal jumps. If you encounter a bcall, replace the label with the corresponding ti-83 label. If the bcall isn't supported by the ti-83, replace it by a call to a routine that does the same and that you add at the end of the program (and make sure you don't add it multiple times.) Befoire 'emulating' the next instruction, check if it was already read. If not read, then continue emulating normally. Else, continue emulating from the location stored in the relative jump stack. If that stack is empty, stop emulating, show the user that the conversion failed and terminate the program.

If it exited correctely because of a ret, then add some code at the start that sets up free, useable RAM memory at the standard 83+ locations (when nessicary). Keep 3 bytes free at the end of this one and save the location. At the end of that routine, add an other routine that cleans up that ram and formats it in the way that the ti-83 OS suspects it, and add a ret to the end. Now replace the 3 bytes you kept free with a call to the start of the program (thus to the end of the 2nd routine). Save the program in the proper 83p format, and show the user a message that it finished converting and that he has to try it on an emulator first, backup his data, and that you're not responsible for any damage to calculators caused by this program, ...

This should work on any program (not app) that doesn't use a shell, jump tables or SMC.

...

Look at you ben_g, I remember back when you couldn't multiply, and now you are converting 83+ programs to 83 program, I am very impressed by your progress. And yes, in theory, that should totally work.

Ok, the idea was originally to create a shell live managing that. I think it's tough, though.

Yeah, it's not an easy project at all. Honestly, I think the best way to do this would be to try to port an 83+ rom to the 83, it would take some serious work, but I think it would work in the end.

"Yeah, it's not an easy project at all. Honestly, I think the best way to do this would be to try to port an 83+ rom to the 83, it would take some serious work, but I think it would work in the end."

Very good idea indeed but this would be very tough cause the TI 83+ OS uses flash memory !

As far as i can remember, anyone who released something for the 83+ also released an 83 (and often an 82) version as well, ESPECIALLY after ion came out and made it so easy to do. Actually, it used to be that nobody bothered porting their 83 games to the 83+! Funny how things change Now that the newer calculators are faster with more memory, for a lot of these new programs there's probably not much you can do other than a complete rewrite. Btw, can Axe spit out an 83 binary as well?

An on-calc emulator would be pretty cool, though i think an 83 emulator for the 83+ would be much more viable (mostly due to memory constraints on the 83).

As a side note, MirageOS had basic 82 emulation back in the day. I think Sam Heald did a lot of the work, but other folks at DS who are still around might have interesting insights. It might be worth looking into. I remember playing Punchout 82 (sent over directly from my 82). Not all programs worked well, but it was still kinda cool.

I don't think it's possible to do that. The OS is stored in ROM.
*Edit* Authors can just create their programs to use the ION shell and compile one version for the 83 and one version for the 83+.