Bento Box Lang

LISP macros
Standard imperative syntax
Extensive math library
Complex and Rational numbers
native machine types for math
As fast as C
GPU and Distributed computing capability
LLVM based
Calling C functions directly
Multiple dispatch
Unicode UTF-8
Type-bound operators
types are runtime objects
Runtime type inference
Open Source
Lightweight Green threads/coroutines
GC is incremental with no pauses
Shell capabilities and REPL
Multidimensional arrays
True module system and textual #inclusion
Reflection and access to intermediate bytecode
Can be embedded inside C code with a single header

>>32
I could spend much time implementing this, but my version of C would be non-standard and unsupported by all other compilers.
As i stated i want the standard modified to allow #macro to execute at compile time and produce code, as in Julia. Its been decades since C preprocessor got any notable improvement.
C isn't going anywhere and improving C preprocessor improves everything thats written in C/C++, languages,OSes, virtual machines and interpreters. Basically, one improvement in C preprocessor is equivalent to improving hundreds of languages and millions of programs. I don't expect anyone to understand it, but "primitive" C preprocessor is essentially the most important language on Earth as the first stage of C/C++ compilation which generates C/C++ code, which drives everything else(virtual machines, OSes, languages,etc). Productivity of programmers is directly proportional to amount of code C preprocessor produces.
LISP macros are a shortcut in lisp to create domain specific code by interpreting the macros as code generating code.
All that needed is to add interpretation of macros as C statements returning strings of code to be inserted into the program.
It doesn't need to be complex:
#macro result(a,b,c) //executed at compile time
char * result_code_string=malloc(1000);
sprintf(result_code_string,"%s%d*%f",a,b+2,c+3.0)
return result_code_string
#endmacro
result("double j=(k())+" , 22 , 2.0 );//macro invoked
double j=(k())+24*5.0;//final macro expansion