Ok, finally managed to see the video (and get permissions to post here).
1st - The nostalgia is real (GM 8).
2nd - Kudos on making your own language, that is always a nice accomplishment!
Now for the actual comments on the video.
You already know (from my status update comments) that I would personally prefer a slightly different syntax, however this video definitely made that more than just a personal preference. The issue I have is that with the current syntax there seems to be a mix between different concepts of the language (or from a language design standpoint). For example, there seems to be a mix between what are global variables to the Shadow language itself and its namespaces (e.g.
$a = 50
and
$a::a = 50
,
$a
is both used for accessing the global variable and the namespace). Also, a global variable for the Shadow language and a global variable for GML don't really seem like two different constructs from a language perspective (although implementation wise I know they differ), but in the syntax they are again treated differently (e.g.
$score = 50
vs
&score = 50
). Similarly, Shadow functions need to use the
$function
notation while built-in functions do not.
So the summary of that comment is that either the syntax is confusing and it seems that a lot of different concepts are mixed or maybe you intended it that way in which case my comment is that a lot of different concepts seem to be mixed up.
Another comment (but this would be fixed by the autocomplete support and isn't strictly language-related) is that if you need to switch between two code editors often to code then it is highly inefficient and off-putting. If I recall correctly in GM 8 there was still a file
fnames
somewhere that listed all of the functions and their arguments. You could use that for generating the autocompletion support (or as I started doing on one of my languages at that time - generate core modules that delegate to GameMaker function calls but that are declared as the custom language. That way your editor only needs to understand one of the languages, etc).
Aside from that it's very nice that you actually compile to GameMaker. Have you considered supporting an interpreter on the GM side to allow Shadow code execution at runtime? For GM 8 it isn't very relevant due to
string_execute
but if you port it to more recent versions of GameMaker it can be a very neat feature.
Some things you might find interesting:
- The JAI programming language, created by Jonathan Blow (creator of Braid and The Witness). The compiler is not officially released yet but on his YouTube Channel you can find streams on the implementation of some parts of the compiler as well as the official demos of the language, where he discusses language design and his line of thought in detail.
- The Odin programming language, which was created by gingerBill and draws a big influence from the JAI programming language. However this one does have a released compiler that you can look into, other than also some demos on YouTube and some streams on Twitch. As Jon Blow, Bill also seems to have some very strong opinions about language design. Unlike JAI, Odin is meant to be less game oriented and more systems programming oriented.
Also, have you considered just implementing a custom backend to an existing compiler? For example, imagine you like how Kotlin, Rust, Elm or any other language looks like and just want it to compile to GML. You could take their compiler and just replace the backend to produce GML instead of JVM bytecode, native code or JS. That way you have support from pretty much any editor and you leverage all of the optimizations and such that those compilers already bring. Of course that since it seems your goal is the language design itself this might seem counter-productive, but it could give you quite a nice look into the design decisions behind those languages, which can be valuable in itself.
Sorry for the wall of text and keep up the good work on that language!