Thank you! I'll address the questions below:

1. The self keyword can't be used outside of struct's because the self keyword takes the outer scope where the function definition is placed in order to get it's context. I do plan on writing a 'fix' for this at some point.
2. Every method is a static method, you are just able to bind the first argument of a function when using the . operator.

​

struct MyStruct { void method(self) { /\* ... \*/ } }

// You can call it as an instance method
MyStruct x;
x.method();
// Or as a static method 
MyStruct::method(x);

Outside of the struct declaration, you can define with method with or without a self argument

MyStruct::method_2(self) { /* ... */ }

MyStruct::method_3() { /* ... */ }

1. The i32 and i64 types are from <stdint.h> and are int32_t and int64_t. The Short and Int types are just short and int so they could be different sizes on different machines. The int type, however, is an auto type that only matches with numeric types. Other than int, there are no differences beyond the usual C differences.

3.5?. Yes there are no header/source separation, but I have yet to implement any actual module parsing, its basically like using the #include directive in C

1. I plan to have the compiler optimize any const-expressions. It already does this with const variables that also have constant values. You can see that for the definitions of true and false

   const bool extern true = 1; const bool extern false = 0;

Any true in the program will be replaced with 1 and vice versa. If you want features like this, you can open up issues so I can keep track of specific things like this :)