Miyuki's Recipe Chef

or Miyuki's Recipe Cooker

A Makefile replacement for my personal projects, you can use it in your projects too if you'd like.

Writing Recipefiles

They're uncanningly similar to makefiles, so lets take an example:

# Here's a comment, SOURCES and OBJECTS are both variables, not constants!
SOURCES = $(list "./test/source/" "*.c")
OBJECTS = $(replace $SOURCES ".c" ".o")

EXE = test/test

$(mkdir test2)

all: test

run: test
    $(exec $EXE)

test: $OBJECTS
    $(exec echo "hello world")
    $(exec clang-19 $OBJECTS -o $EXE)

"*.o": $SOURCES
    $(exec clang-19 -c $(replace $o ".o" ".c") -o $o)

Let's break down this Recipefile, shall we? the first 4 lines we initialize 3 variables: SOURCES, OBJECTS and EXE.

on Sources, we run a command named list, the awkward $(<insert name> ...values) syntax refers to invoking a command in the Recipe Cooker.

on Objects, we replace every occurance of .c to .o in the Sources variable, and make it the value of Objects.

on Exe, it's self-explanatory: it's simply the output executable name.

Targets

Just like in a makefile, we specify targets with a similar syntax:

<target-name>: <dependencies...>
    $command1....
    $command2.....

So what happens in the example if you do mrc test? simple, the recipe cooker will first solve it's dependencies. if they're either values or specified as a target. *Note that MRC doesn't refers to targets as "targets", but instead as "recipes"

Here's what mrc test (from the example) will do:

• run the *.o recipe for every object file in OBJECTS, and ensure that all of the files/targets on SOURCES exist or need to be run beforehand
• if execution on the *.o recipe is successful, it returns to the test recipe
• runs the commands on the test recipe and outputs EXE.

List of commands

1. list: lists files in a directory specified by the first value, the second value is a wildcard to match the entries of the directory against. Note that in the example, we list the ./test/source/ directory and only list the files that end on the .c extension.
2. replace: replaces every occurance of the second value by the third value on the first value. sounds complicated? in the example, we: replace every occurance of .c to .o in the SOURCES variable.
3. mkdir: creates the directories you specify to it, if one already exists it simply will have no action, for example: $(mkdir test2) will create a folder named "test2" if it doesn't exist.
4. exec: executes a shell command, in the example we run: $(exec clang-19 -c $(replace $o ".o" ".c") -o $o) which invokes clang-19 on your shell.
5. make: Invokes another file recipe, if for example you did $(make test) the rice cooker will prepare test before continuing

BUILDING

To build MRC, you'll need a D compiler and dub, a D language project manager.

For debug builds, use dub build, for release builds, use dub build -b=release. The executable will be located at ./mrc if the build was successfull.

INSTALLING

MRC has 0 dependencies, so you can get away with simply copying mrc into your bin folder. Alternatively you can add MRC's folder into your PATH environment variable.

Note: I provide pre-built binaries for MRC in the releases page, if you wish. (they're statically linked against musl too, don't worry about the lib-c.)