The language I chose was F#. On top of Nemerle. What does this mean? I do not know software engineering nor do I have the time to learn it. So I use something I am more comfortable with, abstract maths as a crutch to help make things go smoothly. Most of the code will be written in F# with Nemerle used to implement the framework or more specifically, the platform. First on F#.
F# is a powerful, succinct, functional, well abstracted language that is very good at large data manipulation and handling complex data-structures. Well suited to doing mathematical heavy lifting. F# is also at least as fast as C# on average (faster on some things, slower at a few). F# is also a well maintained and updated language and remains a priority for the developer(s) who works on it. Next.
Nemerle is also a succinct, functional, powerful hygenic meta-capable language. It is also a language designed with much insight and foresight. However, although it is still being actively updated it is not improving at a very encouraging rate. The language has sort of taken a backseat to other projects for the developers. The core of the language is well founded. However, venturing far outside that core is risky as the edges of the language are still unstable. Nonetheless it remains a powerful well thought out language.
Because of what I plan to do and how I plan to do it, I need as a base a language that is very close to its own specification. As a language which exposes its entire syntax tree, Nemerle fits that bill quite well. I plan to use it to create an environment where I can easily explore and implement my ideas, with natural self documenting code. As stated, most of the programming - data structures and algorithims - shall be done in F#. Nemerle will be used to tie things together since it can be pruned and easily adjusted to be more like one prefers. Including making it operate seamlessly with F#. I think. I plan to leverage and mainly use Nemerle meta-capabilites to help more easily implement my "nonstandard" approach.
Oh yes. the basic structure of the engine is a category.
If your not sure what it is imagine bascially taking a generic algorithm/function where you have unknown variables at compile-time but you know a more specialized optimal version for specific cases. What you can do is multi-stage it for when varibles are known at runtime and it will always use the more optimal version for those cases.
Of course you can do this using virtually any .NET language via lightweight code generation (LCG) using reflection with DynamicMethod but this method is quite low-level and it's not declarative and the language is not the same language used (or subset) to write it, apparently LINQ uses LCG to optimize expressions so if you use quotations with LINQ you get declarative runtime specialization for free.
There is one slight downfall with this method in F# as compared to properly implementated runtime multi-staging (as is done with MetaOCaml) which is a slight overhead with using DynamicMethod but it's not so bad so long as whats actually being done out weights the cost of DynmamicMethod.
Anyways you might want to think about whether you really need the full power of nemerle macros and extending syntax or whether F#'s quotations & writing combinator libraries is enough for your needs.