Goals

Be an efficent compilation target for typed lambda calculi
Be substantially easier to translate to than machine code.
Run cross-platform on as many operating systems and architectures as possible. (bare minimum 32-bit).
Allow for code completely independent of the host machine.
Leave memory managment out of the question for the compiler writer.
Provide significant IO functionality.
Have methods for representing algebraic data types built into the machine.
Provide efficient native methods for manipulating commonly used types
- Strings (don’t represent as a list of characters, god)
- Characters
- Integers
- Floating point numbers
- Raw bytes
- Lists (cons linked list), efficient map and foldr builtin would be really nice
- Arrays (constant lookup continous memory)

Non-Goals

Safely error out or leave catchable exceptions when instruction is called with wrongful operands.
Dynamic linking, creating object files with polymorphic types.
Lazy evaluation.

Provide a compiler from a simply typed lambda calculus, coupled with a small standard library which would confirm type safety of all used instructions. Maybe go even further? System F?
Maybe some vector operations? You could reasonably operate on chunks of the stack.

Provide more complete IO functionality, such as networking, etc. (this is not likely to happen)
Provide some sort of FFI (this is not likely to happen)
It’s possible one might be able to JIT compile some stuff?