See also on /r/gamedev [0].<p>After years of dealing with points of frustration in C++ land, I've created my own programming language. It emphasizes compile-time code generation, seamless C/C++ interoperability, and easier 3rd-party dependency integration. It's like "C in S-expressions", but offers much more than just that.<p>I had a hard time trimming this article down because of how excited I am about the language. Feel free to skim and read more in the sections that pique your interest.<p>I don't expect everyone to love it and adopt it. I do hope that some of the ideas are interesting to fellow programmers. I found it eye-opening to realize how much better my development environment could become once I opened this door.<p>[0] <a href="https://www.reddit.com/r/gamedev/comments/kh1p0a/cakelisp_a_programming_language_for_games/" rel="nofollow">https://www.reddit.com/r/gamedev/comments/kh1p0a/cakelisp_a_...</a>
Nice! I've always been a proponent of thinking about C++ as "C with templates" rather than "C with classes," and once you realize that templates are just AST expanders, it becomes apparent that C++ is just a bad lisp :)<p>I made the same thing a while back, and one of the neat simple things you can do is implement function-overloading a la C++. All you need is to define a way to serialize types to strings that are valid identifiers; then you (1) append the string-forms of the types of each function parameter to the name of the function at the definition site, along with a normal function that will do the dispatching in the second part, and (2) do the same thing for the type of the arguments at each call site. Et voila! Function overloading! Not quite as powerful as C++, which takes conversions and stuff into account, but it's an interesting experiment nonetheless. You can see how I did it here: <a href="https://github.com/zc1036/ivy/blob/master/src/lib/std/overload.icl" rel="nofollow">https://github.com/zc1036/ivy/blob/master/src/lib/std/overlo...</a> (DEFUN2 is the version of DEFUN in my language that supports overloading.)
Very cool project, great to see more s-expression based languages. I maintain a list of lisp-flavored languages [0], so I will add Cakelisp there.<p>How did you implement the macro expansion? Are you translating the macros to C/C++, then compile it with C/C++ compiler and execute the temporary binary or do you have an interpreter for that?<p>I work on a somewhat similar project called Liz, which is basically a lisp-flavored dialect of Zig [1]. I did not implement user-defined macros yet, planning to learn more about comptime and its limitations first. But the compiler itself uses macro-expansion to implement many features.<p>[0] <a href="https://github.com/dundalek/awesome-lisp-languages" rel="nofollow">https://github.com/dundalek/awesome-lisp-languages</a><p>[1] <a href="https://github.com/dundalek/liz" rel="nofollow">https://github.com/dundalek/liz</a>
> Lisp has extremely powerful code generation, but makes serious performance compromises<p>This is a serious exaggeration.<p>Common Lisp has extremely good compilers that can meet C performance.<p>There are plenty of Scheme implementations (I use Chez) with very good performance characteristics too.
Some well-known existing work in this exact area:<p><a href="https://github.com/kiselgra/c-mera" rel="nofollow">https://github.com/kiselgra/c-mera</a><p><a href="https://github.com/eudoxia0/cmacro" rel="nofollow">https://github.com/eudoxia0/cmacro</a> (Written in Common Lisp, doesn't use S-exp syntax)<p><a href="https://github.com/tomhrr/dale" rel="nofollow">https://github.com/tomhrr/dale</a> (Prev disc: <a href="https://news.ycombinator.com/item?id=14079573" rel="nofollow">https://news.ycombinator.com/item?id=14079573</a>)<p>Newer stuff:<p><a href="https://github.com/saman-pasha/lcc" rel="nofollow">https://github.com/saman-pasha/lcc</a> (No mention of meta-programming)<p>Lesser known:<p><a href="https://github.com/deplinenoise/c-amplify" rel="nofollow">https://github.com/deplinenoise/c-amplify</a> (No docs, no update since 2010)
> While languages like Rust offer benefits in terms of security and stability, they cost programmers in terms of productivity. It makes sense to value safety so highly if your code is safety-critical (operating systems, aerospace, automotive, etc.), but it's much less valuable when safety isn't as important (e.g. in games).<p>Just want to note that there is a large benefit to this kind of safety even if you're not writing safety-critical code: lack of bugs! The biggest benefit I've seen from rust is that entire classes of bugs, some of which can be extremely difficult to root cause and fix, are removed by design. So you spend significantly less time on the later half of the project tracking down bugs, which is more than enough to offset the productivity loss at the beginning.
This reminds me a lot of c-amplify. I didn't see it in the author's list of languages they tried so I thought I'd mention it, it has a lot of neat ideas for building a lispy C.<p><a href="https://voodoo-slide.blogspot.com/2010/01/amplifying-c.html" rel="nofollow">https://voodoo-slide.blogspot.com/2010/01/amplifying-c.html</a>
<a href="https://github.com/deplinenoise/c-amplify" rel="nofollow">https://github.com/deplinenoise/c-amplify</a>
This looks great. The S-expr syntax is my favourite, though I'd have preferred a Clojure-like one personally, a CL inspired one is still fine.<p>Some of the downsides mentioned can easily be taken care of by a macro I believe. Like the path traversal can be flattened with a macro most likely. Same thing for the type definitions.
It looks like an interesting project. The syntax for pointers is what grabbed my attention at first. Would really need to spend some time with this to know how it would work in practice.<p><pre><code> const char* myString = "Blah";
(var my-string (* (const char)) "Blah")</code></pre>
Is there any reason this couldn't/shouldn't be used for applications besides than games? Other than your motivation/goals coming from solving game development problems, I didn't see anything that makes this useful for _only_ games.<p>Edit: The GitHub repository implies that this could be used for purposes other than games:<p>> The goal is a metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games).
I’m interested in this “comptime” aspect. Zig has it too, but are there any other languages that use this? I’m under the impression that there’s a distinction between comptime evaluation and typical lisp macros.