The low level byte language would be the bridge between the executable and the higher level languages. It would be either interpreted or compiled into native binary. It would be something near to an assemly but little higher level with virtual instructions and system API.
This would be basically the human readable mapping of the low level language and could be compiled into it or disassembled from it. Use of it would most probably become important by enabling to embed it into other languages or to write super optimal component for programs.
Rich language based on todays modern concepts and abstractions which would compile into low level byte language. Further secions will discuss this language, as the existence of it is the main goal. It should be also possible to write more high level human languages.
The top level compilers would compile the human languages into byte languages. The result could than be interpreted relatively quickly or compiled and optimized further into native binaries. Developers could release cross-compatible programs while still hiding the high level source. Also the users could decide to compile them on their machines. Sharing libraries between developers would be also easy.
The low level interpreter and compiler would have several functionalities. The obvious one is to run or compile byte language. Static byte code libraries could be compiled into one big byte code and shared byte code libraries can be used by both binaries and interpreted code. The intepreter would have a shared library that would be linked with the binary when using byte code libraries. Static native libraries could be compiled together and shared native libraries could be used by both interpreted code and binaries.
This would be the standard high level language in the infrastructure described abowe. It is a concept. The core motivation is to create a language that merges some great features in other languages, while adding some new ones and trying to eliminate the unnecessary, to keep things logical. It is mostly inspired by C-plus-plus and D. Note that the descriptions here are changing rapidly. Things will be further discussed and evolve since the main idea is very young. Some things have been already rethought and some ideas still only exist in our heads.
We could say this language is multi-paradigm. Main goals are to provide a simple polymorphic aspect, mechanisms for compile time function execution, logical macro and templating features, nice lambda calculus based programming, contract features and some high level standard libraries. These concepts are not trivial to merge and sometime decisions have to be made.
The Alpha Language compilation would be done in three clearly separate steps. These should be done independently and their syntaxes should be cleary distinguishable. First would the macro preprocessing. Basic string manipulation with simple loops and checks. The second layer would be compile time manipulation. This layer would already have knowledge about types and other things. This would handle tuples and templates and could do evaluation and inlineing when it is possible. It could do type operations or compile time rephlection. The last layer would be the optimization and code generation.