rusty-dos VS rust_dos

Some kind of framework: https://github.com/Serentty/rusty-dos

I assume that's what rusty-dos is using, given this bit from the README:

I know, but if you want to do dos, you can .

Now, being both a Rust enthusiast and MS-DOS nostalgic, I have, multiple times, tried closing the gap on writing applications for real DOS systems in Rust. Unfortunately, this is not without issues, and there is not a clear path on how to go with this yet. More on existing efforts here.

You do not need segment registers much if you stick to the tiny model. Here is someone compiling Rust to a 16-bit DOS COM executable:

https://github.com/o8vm/rust_dos

Not sure what the approach would be for them to expand that to support segments.

In DJGPP there are macros to allow your protected mode application access physical real-mode addresses (like when you want to write to video RAM). I don't know if IA-16 also does something like that, or if they added far/near keywords to the language like old 16-bit C compilers did (at least the ones I used).

Free Pascal has helper-functions to work with segment+offset pointer pairs, also without having to modify the language itself. I think that would work well enough in C, but I guess the old method of adding non-standard keywords was seen as slightly more convenient.

Demo: https://github.com/o8vm/rust_dos

It is probably possible for almost any old platform with some cross-compilation magic, but not anything that will be officially supported as the compiler-makers focus on modern systems. There is for instance an unofficial 16-bit DOS backend for GCC and at least one or two projects to compile Rust to DOS-executables (that I assume use Clang?) (in addition to 32-bit DJGPP(gcc) for MSDOS that I linked to above). Probably are similar projects to target 68k somewhere?