Metaprogrammable, hot-reloadable, no-GC language for high perf programs (especially games), with seamless C/C++ interop
This is a programming language where I [[https://en.wikipedia.org/wiki/Youcan%27thaveyourcakeandeat_it][can have my cake and eat it too]]. I wanted to do this after my [[https://macoy.me/code/macoy/LanguageTests][LanguageTests]] experiment revealed just how wacky Common Lisp implementations are in regards to performance. I was inspired by Naughty Dog's use of GOAL, GOOL, and Racket/Scheme (on their modern titles). I've also taken several ideas from Jonathan Blow's talks on Jai.
The goal is a metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games).
It is a transpiler which generates C/C++ from an S-expression syntax. Cakelisp takes some inspiration from Lisp, but is not compatible and does not aspire to become "a Lisp".
You can see the [[https://macoy.me/blog/programming/CakelispIntro][introduction to Cakelisp]] and check out the [[https://news.ycombinator.com/item?id=25491568][Hacker News announcement thread]].
For more advantages, see [[file:doc/NeatUses.org][doc/NeatUses.org]].
Some of these features come naturally from using C as the backend. Eventually it would be cool to not have to generate C (e.g. generate LLVM bytecode instead), but that can a project for another time. * Terms Cakelisp is copyright (C) 2020 Macoy Madson ~[email protected]~.
Licensed under ~GPL-3.0-or-later~, with added [[https://www.gnu.org/licenses/gpl-faq.en.html#LinkingOverControlledInterface][Linking Over Controlled Interface]] exception. ~runtime/~ is licensed under MIT License.
Please see [[file:doc/Legal.org][doc/Legal.org]] for a detailed explanation.
Contact [email protected]~ if you would like to negotiate an exception for your use-case. * Building Cakelisp itself ** Linux Run ~Build.sh~ in ~cakelisp/~:
cd cakelisp ./Build.sh
This script first builds cakelisp explicitly, then uses the ~cakelisp_bootstrap~ executable to build Cakelisp using Cakelisp. Subsequent executions of ~Build.sh~ will also build using Cakelisp, which means all the caching features will be in effect (making builds much faster).
You can then run ~./bin/cakelisp~. Have fun! A simple test:
./bin/cakelisp --execute test/Hello.cake
It shouldn't be hard to build Cakelisp using your favorite build system. Simply build all the ~.cpp~ files in ~src~ (with ~UNIX~ defined), then link them into an executable which also links ~-ldl~. Leave out ~Main.cpp~ and you can embed Cakelisp in a static or dynamic library! ** Windows Windows does not come with a compiler installed by default. In order to provide a solid "native" experience, Cakelisp supports MSVC. It should be possible to compile on Windows using MinGW as well (in which case, you should refer to the Linux instructions, or open an Issue requesting Windows-native MinGW bootstrap building).
Once you do have a compiler, I aspire to make Cakelisp the /easiest/ way to make C/C++-based projects on Windows. You shouldn't need to touch Visual Studio project files ever again!
The following instructions will assume you are using MSVC.
Ensure that you pick the C++ track, and make sure the C++ Developer Tools box is checked (if you clicked C++, you shouldn't need to make any other changes).
Note that you need to upgrade depending on what kinds of projects you use, e.g. if you are in a team making proprietary software, you must pay for Professional or Enterprise 2. Download Cakelisp. If you have git or any git client installed, clone this repository using the URL provided on this page. If you don't have Git, download the ~.zip~ file from the repository home page 3. In ~cakelisp/~, double-click ~Build.bat~.
This should automatically find your Visual Studio and set the proper environment variables. If it doesn't, see the [[https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-160#developercommandfile_locations][MSVC documentation]] on running from the command line. You may have to update the path to ~vcvars64.bat~ set in ~Build.bat~ to whatever Visual Studio version you installed. You should be able to find the script via searching for ~vcvars~ in your ~C:\Program Files (x86)~ folder.
If you have ~cakelisp.exe~ in ~bin/~, you are ready to use Cakelisp! Due to the use of environment variables to select the compiler, you can only build programs if you've set the variables. To do so, refer to ~Build.bat~, or create a ~.bat~ file based on this template:
echo off rem Set environment variables for compiler/linker selection rem Include help message in case this file isn't present if exist "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat" ( call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat" ) else ( echo This script builds using MSVC. echo You must download and install MSVC before it will work. Download it here: echo https://visualstudio.microsoft.com/downloads/ echo Select workloads for C++ projects. Ensure you install the C++ developer tools. echo If you're still seeing this, you may need to edit Build.bat to your vcvars path echo Please see the following link: echo https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-160 goto fail )
rem EDIT ME! If you keep this build script in the same directory as your project, update rem "bin\cakelisp.exe" to wherever you have a built version of Cakelisp rem Add --execute before the .cake files to run your project after building "bin\cakelisp.exe" YourProgram.cake
rem Make the result clear @if %ERRORLEVEL% == 0 ( echo Success! goto success ) else ( echo Error while building goto fail )
:fail goto end
:success goto end
:end rem Give the user a chance to read the input (not required) pause
*** Building from Visual Studio It is also possible to create a Visual Studio project to build Cakelisp. This is especially useful if you are debugging Cakelisp itself.
You can refer to an existing project in ~cakelisp/VisualStudio~. The steps to create a new project are as follows:
Next, run ~set~ in that same Command Prompt. Select all of the text output by that command and hit Enter to copy it. Finally, return to the ~Environment~ setting in Visual Studio, click the down arrow on the field, then ~~. Paste into the top text field, then hit OK. - Expand ~Configuration Properties -> C/C++ -> Preprocessor~ - Double click or ~~ the ~Preprocessor Definitions~ field and add the following to the beginning: #+BEGINSRC sh CAKELISPEXPORTING;CRTSECURENOWARNINGS;WINDOWS; #+ENDSRC ~CAKELISPEXPORTING~ indicates Cakelisp should export its symbols to DLLs. The ~CRT~ definition is going to be removed eventually; it makes MSVC more lenient with some errors Cakelisp has. The ~WINDOWS~ definition ensures you build with Cakelisp's Windows-specific code enabled - Hit ~F5~ or go to ~Debug -> Start Debugging~. Visual Studio will build Cakelisp, and if it succeeds, launch Cakelisp. If you have no ~Command Arguments~ set, you should see the Cakelisp help output in a command window.
This project is for building Cakelisp itself; you don't need to make any new projects for your projects written in Cakelisp (in ~.cake~ files). Change the ~Debugging -> Command Arguments~ setting to build different Cakelisp files, or change the ~Working Directory~ to build a different Cakelisp project (e.g. one in a separate repository). ** Dependencies Currently, Cakelisp has no dependencies other than: - C++ STL and runtime: These are normally included in your toolset - Child-process creation: On Linux, ~unistd.h~. On Windows, ~windows.h~ - Dynamic loading: On Linux, ~libdl~. On Windows, ~windows.h~ - File modification times: On Linux, ~sys/stat.h~ - C++ compiler toolchain: Cakelisp needs a C++ compiler and linker to support compile-time code execution, which is used for macros and generators
I'm going to try to keep it very lightweight. It should make it straightforward to port Cakelisp to other platforms.
Note that your /project/ does not have to include or link any of these unless you use hot-reloading, which requires dynamic loading. This means projects using Cakelisp are just as portable as any C/C++ project - there's no runtime to port (except hot-reloading, which is optional). * Building a project using Cakelisp Cakelisp will automatically figure out how to build simple projects into executables.
For more complex projects, many hooks and variables are provided for overriding the build process. Your code is defined in Cakelisp, and so are all build commands. This gives the code the ability to know how to build itself.
For example, you could have a ~.cake~ module which includes a 3rd party graphics library. By importing that module, the module's compile-time hooks are added to the build process, which can do things like add the 3rd party graphics library's ~lib~ files to the link stage.
The build hooks are all regular Cakelisp code, which means you could do something as advanced as cloning a repository from the internet, launching a subprocess to ~cmake~ and ~make~ that project, then let Cakelisp finish the build by linking the output libraries.
One huge advantage to defining your build process in a "real" programming language (as opposed to a domain-specific language interpreted by a build system) is that you can attach a debugger and single step through the build process when things go wrong. * Learning Cakelisp Check out [[file:doc/Cakelisp.org][doc/Cakelisp.org]] for a detailed explanation of the Cakelisp language and build system.
Explore ~test/~ and ~runtime/~ for examples of Cakelisp code. [[https://macoy.me/code/macoy/gamelib][GameLib]] is a collection of modules built for making games in Cakelisp. Check both ~src/~ and ~test/~ in GameLib for more extensive code examples. * Tooling support ** Emacs Open ~.cake~ files in ~lisp-mode~:
(add-to-list 'auto-mode-alist '("\.cake?\'" . lisp-mode))
** Build systems A build system may work with Cakelisp, because Cakelisp outputs C/C++ source/header files. Cakelisp must run before your regular build system runs, or in a stage where Cakelisp can create and add files to the build. This is because Cakelisp handles its own modules such that adding support to an existing build system would be challenging.
Ideally, you should be able to rely on Cakelisp's built-in build system. This allows Cakelisp files to know how to build themselves. ** Debugging See [[file:doc/Debugging.org][doc/Debugging.org]]. Cakelisp doesn't really have an interpreter. Cakelisp always generates C/C++ code to do meaningful work. This means the Cakelisp transpiler, macros, generators, and final code output can be debugged using a regular C/C++ debugger like GDB, LLDB, or Visual Studio Debugger.
Mapping files will make it possible to step through code in the Cakelisp language (i.e. not in the generated language). This is similar to how debuggers allow you to step through code in C files, when under the hood it's actually stepping through machine code. It will require building support into your editor in order to properly jump to the right Cakelisp file and line (among other things). * Similar applications/languages See [[file:doc/VsOtherLanguages.org][doc/VsOtherLanguages.org]] for projects similar to Cakelisp.