# 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.

# Nicities (plausible)

* 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.

# Nicities (dreaming)

* 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?

# Ideas