Cate is a simple and fast build system for C/C++, its syntax is much simpler than the other build systems. While Cate is slower than Make, it's much easier to set up and create projects and libraries with.
Cate does not have a Windows release as of yet because of our laziness
Unlike CMake and other build systems, Cate does not require Make and is not Turing complete. Cate is more like a wrapper state-machine for GCC/clang than an object oriented build system (unlike CMake), or a build system programming language (also unlike CMake).
Cate is not written in Rust and never will be; Cate has 0 memory leaks thanks to a practice known as "knowing how memory works".
Do note:
- We know the source code isn't great, it was our first project.
- Cate uses Catel, a messy file that allows us to set a default file.
- Cate does not support string splitting.
- This readme is full of little jokes. No offense intended to any other build system... except Autotools.
You may be wondering what issues Cate solves, let us clear it up for you!
- It's extremely easy to learn, it doesn't require learning an entirely new language just to build a project!
- It (unlike CMake) has a consistent syntax that doesn't require documentation.
- It's smol, it has everything it needs and a little more to keep the 1% happy.
- It's colorful and fun to use, not everything has to be monochrome.
- Cate, unlike Make, just cates sense!
If you're still here; that means you suffered enough CMake (or Autotools) to reconsider your life choices, Thank you for choosing Cate!
Run the following commands:
wget https://github.com/TheMilkies/Cate/releases/download/v2.9.5/cate_2.9-5_amd64.deb
sudo dpkg -i cate_2.9-5_amd64.deb
rm cate_2.9-5_amd64.deb
Run the following commands:
mkdir catering
cd catering
wget https://github.com/TheMilkies/Cate/releases/download/v2.9.5/linux_cate_v2.9.5.zip
unzip linux_cate_v2.9.5.zip
sudo ./install.sh
cd ..
rm -rf catering
Make sure you have these installed:
- A Unix-like operating system
- A C++17 compiler (
g++
orclang++
)
Run ./build.sh
, It'll ask you if you'd like to install at the end.
If you're using cate <= 1.3, run sudo cate legacy
.
Run cate
, it'll ask you if to install after building.
Unlike Make and other build systems; it'll automatically detect the thread count.
Cate's CLI is intuitive, but doesn't offer much more than necessary.
-tN
(and-jN
): Set thread count to N. Cate automatically detects thread count so this isn't required.-l
: Lists Catefiles in Catefiles directory (set by Catel).-y
: Install without asking (always answer 'y').-n
: Don't install (always answer 'n').-D
: Disable all user-definedsystem()
calls in script.-d
: Print all commands in script without running them. (dry run)-S
: Smolize even if not set in script.-f
(and-B
): Forcefully rebuild project.-v
: Shows the installed Cate version.-h
: Shows help and Cate version.
Create the following structure
cate/
|_ build.cate
include/
src/
|_ main.c
Or use the following commands
mkdir cate include src
touch cate/build.cate src/main.c
You've come this far! Good Job!
Cate breaks most known build-system conventions by forcing you to use multiple files for different targets, and having a file extension (unlike CMake, Make, Autotools, and many more). For a debug build you'll have a debug.cate
, for a cross-platform build you'll have a platformname.cate
.
Cate uses C-like syntax with the exception of it being a "state-machine" rather than a language. It does not support int-literals (0123456789) as of yet (and hopefully forever). Cate supports #comments
in addition to C-comments.
Cate does not support a.property = b.property;
syntax
There are only two class types, Project
and Library
.
Example project
Project project;
project.files = {"src/main.c"};
project.includes = {"include"};
project.libs = {/*add libraries here*/};
project.flags = "/*flags here*/";
project.smol = true;
project.out = "/*out name here*/";
project.build();
Libraries require a parameter called LibraryType
which can be either static
or dynamic
Example library (not in example project)
Library library(static)
library.files = {"src/main.c"};
library.includes = {"include"};
library.libs = {/*add libraries here*/};
library.flags = "-O2";
library.out = "out/liblibrary.a";
library.build();
Cate (since 2.6) does not require the object names to be repeated.
Project proj;
.flags = "-O3";
.files = "src/main.c";
.build();
Both classes have these properties, even if they don't make sense for the class
-
Array<String> files
: Files of the project/library. No default. -
Array<String> incs|includes|include_paths
: Include paths of the project/library. Defaults to"include/"
or"inc/"
if present. -
Array<String> defs|defines|definitions
: Definitions. Default is set by the compiler. -
String out
: The output file name. -
- In projects: Defaults to the identifier.
-
- In libraries: Defaults to "lib" + the identifier + the extension for the library type.
-
String cc|compiler
: The compiler to use. Default iscc
. -
String std|standard
: The C/C++ standard to use. Default is set by the compiler. -
String obj_dir|object_dir|build_dir|build_directory
: The folder it'd store object files in. Defaults to"build"
(orcate/build
if catedir is present), unless a directory named"obj"
is present; where it'd use it. -
String flags
: The cflags of the project/library, All object files are compiled with them. Default is empty. -
String final_flags
: The cflags ran at the end (linking step) of the project/library's compilation. Default is empty. -
bool link
: Whether to run the linking step or not. Default istrue
. -
bool threading
: Whether to add-pthread
to build command. Default isfalse
. (Just syntactical sugar.) -
bool smol|smolize
: Whether to attempt to reduce output-file's size with minimal to no performance loss. Default isfalse
. Do NOT use with libraries. -
LibraryType type
: Type of library,static
ordynamic
. Gets from library "constructor".
void build()
: Builds project/library.void clean()
: Deletes project/library's object files, doesn't affect other projects/libraries!void install()
: Install projects to/usr/local/bin
and libraries to/usr/local/lib
.
-
Array<String> recursive(String path)
: Get all files (or libraries, or include paths) in path ending with an extension. Example:project.files = recursive("src/*.c");
. -
recursive()
Allows subdirectory recursion, Example:recursive("src/**.c")
;
-
recursive()
is also callediterate()
.
-
- If for some reason you don't have enough disk space to type
recursive
, you can dofiles = {"src/*.c"}
- If for some reason you don't have enough disk space to type
-
void system(String command)
: Run command. Will be skipped if user runs Cate with the-D
flag. -
void subcate(String file_name)
: Starts a new Cate "instance" with the passed file name. (since 2.7)
Cate allows you to run another catefile from the current one and use libraries that you built in the other.
static.cate
Library example_lib(static)
.files = recursive("src/lib/*.c")
.build() //will be named "out/libexample_lib.a" automatically
test.cate
subcate("static.cate") //include it here
Project Test
.libs = {example_lib} //we can use it here
.files = recursive("src/test.c")
.build()
All classes use global values as default. There are only 5 global variables you can change, being:
String cc|compiler
String std|standard
String obj_dir|object_dir|build_dir|build_directory
bool smol|smolize
bool threading
Usage example:
compiler = "g++" //global
smol = true
Project proj
.flags = "-O3"
.files = {"src/main.cpp"}
.build()
Project proj2
.flags = "-O3"
.files = {"src2/main.cpp"}
.build()
Project proj3
.compiler = "cc"
.flags = "-O3"
.files = {"src3/main.c"}
.build()
.install()
A Catel file (.catel
) is a dumb file made to point cate at the right directory, and use a default file.
Since 2.8.1; you can create Catel files named:
.linux.catel
.mac.catel
.windows.catel
for those targets.
Here's an example Catel file:
def smol.cate
dir cate
Here's an example of Catel for different platforms:
.windows.catel
dir cate/windows
def smol
.linux.catel
dir cate/linux
def smol
- Yogurt (Creator and Main Maintainer)
- Lemon (Creator)
- Latte (Bug fixer)
Special thanks to
- Make for being hard to work with, and extremely ugly.
- CMake for failing to be an an improvement over make, and becoming so complicated over the years that you need a CMake debugger to use it.
- Autotools for being the worst build system to ever exist.
Without these crimes against humanity, Cate would not have existed.
Thank you; Make, CMake, and Autotools for being so terrible.