Prerequisites

It is best idea to have a look at this post , for better understanding of build process for Arduino (or any AVR MCU). Especially, refer the section " Compile and Upload ". Would be Great if you are able to upload the same code to your arduino, as these will help eliminate any issues on early basis.

Basically, the build process consists of following steps :

Compile : Compile all the source files (C, C++, Assembly) and object files (.o or .elf) will be generated for each of the source files.
Link : Link all the object files (.o) and any library archives (.a) files (if used), to create a single executable (.elf).
Binary image : The executable image (.elf) may not be compatible to run on target hardware (the AVR MCU). Convert it to suitable binary format (here .hex)
Upload and Run/Debug : Upload the program to either execute the program or debug it step by step.

Note that this post specifically applied to AVR 8-bit Arduino boards only. The process will be similar for ARM (SAMD) based Arduino boards, but it will make use different set of tools specific to ARM (Toolchain, etc.)

Why use Makefile when you have an IDE and also arduino-CLI ?

Note this is not something which hasn't been performed before, there is an excellent similar solution already implemented here , but follow along if you would like to know more.

To understand build process and know what's happening in background. Get a better control over build process.
Automate the build process, requiring no human intervention. Create your own build system.
Generate executables for different kinds of builds (like prod, debug, trace) and different optimization levels.
Different platforms (ARM, AVR) and different vendors (Microchip, STM32) offer different IDEs. Using Makefile based build process may help working with different toolchains much easier, and you can get rid of IDEs if you prefer that way.
Specifically for Arduino boards, you can opt for not using Arduino libraries or create and use your version of arduino library. And write raw C/C++ code as you could have done with WinAVR.
Compile arduino sketches with version of avr-gcc toolchain of your choice.
For binary distribution of your libraries, or have a look at disassembly.

Little Bit of Reverse Engineering (helps a lot)

While it is required to have the basic understanding of build process (Compile > Link > Upload > Run/Debug) to work with makefiles, but it doesn't mean you need to start from scratch.

The arduino sketch build process is already documented in detail here . A good start to learn build process, but following through text simply (without mention of which commands are executed) can be hard to understand.

No worries, when you verify (compile) an arduino sketch, the arduino IDE already shows the build log in the bottom section. copy the same to a text file and have a look at it.

Note that make sure to close the Arduino IDE and then open it again and then compile the sketch. Otherwise, you will see that arduino IDE will make use of the precompiled arduino core to speed up the build. This way you will only see the build log of the sketch only and not how core is built.

Try it yourself and you will see this line in build log when compiling the same sketch next time >Using precompiled core

Referring to the build log, you will find the lines similar to one below :

Compiling core...

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\5.4.0-atmel3.6.1-arduino2/bin/avr-gcc" -c -g -Os -w -std=gnu11 -ffunction-sections -fdata-sections -MMD -flto -fno-fat-lto-objects -mmcu=atmega2560 -DF_CPU=16000000L -DARDUINO=10805 -DARDUINO_AVR_MEGA2560 -DARDUINO_ARCH_AVR "-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino" "-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\variants\mega" "C:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino\WInterrupts.c" -o "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\core\WInterrupts.c.o"

This seems a bit complex, but let's compare it with simplified gcc command to compile :

gcc <arguments> -I<path_to_header_files> input_source_file.c -o output_object_file.o

Now, after comparison what we get is :

avr-gcc : the cross compiler

-mmcu=atmega2560 -DF_CPU=16000000L : The target microcontroller (MCU) and its clock frequency.

"-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino" "-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\variants\mega" : The header files

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino\WInterrupts.c" : The input source file

"C:\Users\<>\AppData\Local\Temp\arduino_build_856534\core\WInterrupts.c.o" : The output object file

C:\Users\<>\AppData\Local\Temp\arduino_build_856534\" is the temporary directory used by Arduino IDE for storing files.

Similarly, all the source files within ...\cores\arduino folder will be compiled into respective object files.

Then, all these object files are archived into a single archive file called core.a, refer below commands in build log :

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\5.4.0-atmel3.6.1-arduino2/bin/avr-gcc-ar" rcs "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\core\core.a" "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\core\WInterrupts.c.o"

Also, you will find following line which compiles the sketch.

Compiling sketch...

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\5.4.0-atmel3.6.1-arduino2/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto -mmcu=atmega2560 -DF_CPU=16000000L -DARDUINO=10805 -DARDUINO_AVR_MEGA2560 -DARDUINO_ARCH_AVR "-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino" "-IC:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\variants\mega" "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\sketch\Blink_Mega_2560.ino.cpp" -o "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\sketch\Blink_Mega_2560.ino.cpp.o"

Note that sketch name has been changed from *.ino to *.ino.cpp . So, basically the sketch is nothing more than a C++ source file. There are few details added to sketch while converting it into .ino.cpp file, more on this later below.

Similarly, any libraries will be also compiled and respective object files (.o) will be generated.

And then all the object files (.o) and arduino core library archive (core.a) are linked together to create an executable (.elf). Just for curiosity, try opening core.a file with any archive viewer software like 7-zip and you will find all the object files (.o) within it.

Linking everything together...

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\5.4.0-atmel3.6.1-arduino2/bin/avr-gcc" -w -Os -g -flto -fuse-linker-plugin -Wl,--gc-sections,--relax -mmcu=atmega2560 -o "C:\Users\<>\AppData\Local\Temp\arduino_build_856534/Blink_Mega_2560.ino.elf" "C:\Users\<>\AppData\Local\Temp\arduino_build_856534\sketch\Blink_Mega_2560.ino.cpp.o" "C:\Users\<>\AppData\Local\Temp\arduino_build_856534/core\core.a" "-LC:\Users\<>\AppData\Local\Temp\arduino_build_856534" -lm

Finally, the binary (.hex) file will be generated :

"C:\Users\<>\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\5.4.0-atmel3.6.1-arduino2/bin/avr-objcopy" -O ihex -R .eeprom "C:\Users\<>\AppData\Local\Temp\arduino_build_856534/Blink_Mega_2560.ino.elf" "C:\Users\<>\AppData\Local\Temp\arduino_build_856534/Blink_Mega_2560.ino.hex"

Upon clicking upload button, same binary will be uploaded to Arduino using AVRDUDE.

The hidden "Arduino.h", function prototypes and main.cpp

As briefly mentioned previously, the arduino IDE doesn't directly compile .ino sketch, but it converts into .cpp file and then compiles it, let's see what is inside this .cpp file.

While most of the things are unchanged, there are some notable differences compared to code in sketch :

#include <Arduino.h> at very top.
Function prototypes for setup() and void() functions.

Arduino.h (located in cores\arduino folder) provides function prototypes for all the standard arduino functions like digitalWrite(). And it is included by every sketch.

Now, few questions should arise :

Where is the main() function, from where the execution begins.
How setup() is only executed once and loop() is executed infinitely ? There doesn't seem to be any difference in definitions of both these two functions, so what makes them behave differently ?

The answer to these question lies in main.cpp (located in cores\arduino folder), let's have a look at it.

So, it is the main() function which first calls the setup() function and then repeatedly calls loop() function from an infinite loop.

Required Tools

Any 8-bit AVR Arduino board like Uno, Mega, Nano (you should be able to use it with Arduino IDE). I will be using Arduino Mega 2560 R3 (and also Arduino Esplora)
Also, you must have Arduino IDE already installed. Because we will make use of the "arduino core" files from arduino installation.
Source code editor of your choice (like Notepad++, VS Code, etc.)
GCC-AVR Toolchain (it may also contain GNU Make and/or AVRDUDE)
GNU Make (If not included with toolchain)
AVRDUDE (If not included with toolchain)
Serial Terminal (RealTerm, Putty, SimplySerial etc.)

Let's start

Note that it is always a good practice to avoid a space in directory name, instead use underscores.

Below steps are specific to Arduino Mega and done on a windows computer, but you can follow similarly for arduino board used by you and using a linux machine.

Download the tools above (Source code editor, GCC-AVR toolchain, GNU make, AVRDUDE, Serial Terminal) and install/extract them to directories of your choice. And remember to add given folder to path where make.exe is located.
First, somewhere on your computer, create a directory called Arduino_Makefile
Then within the Arduino_Makefile , create directory structure as per below.

Copy paste the Arduino library source files

From : C:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\cores\arduino

To : \Arduino_makefile\Mega2560\ARL\src\cores\arduino

Copy paste the pins_arduino.h

From : C:\Users\<>\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.23\variants\mega

To : \Arduino_makefile\Mega2560\ARL\src\variants\mega

Download and copy paste following files from respective folder in github repository.

Makefile for compiling Arduino Runtime : \Arduino_makefile\Mega2560\ARL\makefile

Makefile for compiling Arduino Sketch : \Arduino_makefile\Mega2560\blink_arduino\makefile

Blink Sketch : \Arduino_makefile\Mega2560\blink_arduino\src\blink_arduino.cpp

Change the path to different tools in both the makefiles, ignore/comment the QEMU if you don't have it installed as it is not required for this project.

# The Toolchain binaries (Absolute addresses/paths)

# Change these values as per your installation.

# --------------------------------------------------------------------

# GCC - The GNU C Compiler

GCC := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-gcc.exe

# GPP - The GNU C++ Compiler

GPP := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-g++.exe

# OBJDMP - Objectdump utility, for listing symbols, generating disassemblies, etc.

OBJDMP := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-objdump.exe

# OBJCPY - Objectcopy utility, for converting one binary format to another (elf to hex)

OBJCPY := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-objcopy.exe

# AR - Archiver utility, for packing/unpacking object file archives

AR := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-gcc-ar.exe

# QEMU - AVR System Emulator, to run code in an emulator without uploading to arduino

QEMU := D:/SW_3/qemu_install/qemu/qemu-system-avr.exe

# GDB - The GNU Debugger, to debug the program line by line (step)

GDB := D:/SW_11/avr-gcc-12.1.0-x64-windows/bin/avr-gdb.exe

# AVRDUD - to upload the program to arduino

AVRDUD := D:/SW_11/avrdude-v7.1-windows-x64/avrdude.exe

Compile the Arduino runtime by running following commands :

Launch command prompt from this directory and run following commands : \Arduino_makefile\Mega2560\ARL\

make clean_dbg

make all_dbg

After execution of above two commands, there will be an arduino library archive created here : \Arduino_makefile\Mega2560\ARL\debug\obj\ARL.a

Compile sketch by running following commands :

Launch command prompt from this directory and run following commands : \Arduino_makefile\Mega2560\blink_arduino\

make clean_all_dbg

make all_dbg

make bin_dbg

After execution of above three commands, there will be a .hex file here : Arduino_makefile\Mega2560\blink_arduino\debug\obj\blink_mega2560.hex

Upload the sketch to Arduino

Connect the board to your computer using USB cable and observe which COM port it shows up on (look in Device Manager)

Launch command prompt from this directory and run following command : \Arduino_makefile\Mega2560\blink_arduino\

make load_dbg PORT=COM7

If all goes well, you will see TX/RX LEDs blinking on your arduino and sketch will be now running.

So, What the Makefile does ?

If you have observed, we are running commands like "make all_dbg", here :

The make command invokes the GNU make tool and tries to find a file called "makefile" in current directory from where we executed the command.
If a makefile is found, then the make tool will try finding recipe (sequence of commands to be executed) for all_dbg in corresponding "makefile"
If given recipe is found, then make tool will execute the corresponding commands (of recipe) and this will help achieve the required.

Simply, makefile is a way to define your own build system using recipes. Explaining "how to create makefile" is beyond the scope of this article, but you can refer some articles links in references below.

Below are the particulars of makefiles I have created for this project :

Each makefile can process two types of builds : Debug (dbg) and Prod (prd). You will find separate recipes for both these kind of builds like all_prd and all_dbg .
The difference between these two builds is that Debug build preserves the debug information (in .elf file, not .hex file) and prod build does not. Debug information is helpful in debugging with a hardware debugger like J-link, Atmel-ICE or using a software debugger like AVR-debug (link below in references, this one you can use too with supported boards)
Refer any comments in makefile I have supplied, you will need to make changes to where the toolchain binaries are located and if you are using a different directory structure for project.
The approach is recursive, means that the separate makefiles (although identical ones) are used each for Runtime, libraries and project. The makefile for project calls the makefile for all the libraries in order to build/clean libraries. But the makefile for project does not call makefile for runtime, because you do not require to build/clean runtime on each build of the project. Hence, you must build the runtime before build of project and libraries.

Following recipes (for debug build) are there in the makefiles I have created for this project, and a little explanation of what they do :

make lib_all_dbg : this will call the recipe " all_dbg " for all the libraries and build (compile) them.
make lib_clean_dbg : this will call the recipe " clean_dbg " for all the libraries and clean the respective object files.
make compile_dbg : this will compile the source files for given project.
make link_dbg : it will link all the object files (from libaries as well as project) and generate a statically compiled .elf executable.
make bin_dbg : it will generate a .hex binary file from a .elf executable
make all_dbg : this calls lib_all_dbg, compile_dbg and link_dbg in sequence, so that you do not need to run these 3 recipes separately, but make all_dbg will take care of all these and generate .elf executable
make disasm_dbg : to generate the disassembly of object files (both full and source-intermixed disassemblies are done)
make asmble_dbg : to only assemble the source files but do not compile them, this currently does not work but may be fixed in future.
make header_dbg : to print header of the .elf executable
make clean_dbg : to clean (delete) the object files of current project.
make clean_all_dbg : this calls both the clean_dbg and lib_clean_dbg , so that you do not need to run clean commands separately.
make load_dbg : to upload the hex binary to arduino using avrdude tool.
make dbg : to launch the GDB (avr-gdb)

Note about Arduino Esplora

If you compile sketch for Arduino Esplora, you will get to know that Arduino esplora makes use of the same core as of the arduino leonardo, because they both have ATmega32U4 MCU.
Additionally, there is no separate USB to serial converter on Esplora (unlike ATMega16U2 on Arduino Mega), that's because ATmega32U4 has native USB capability. So, in order to upload code to arduino esplora, you will first need to reset it to push it into bootloader mode and upload the code while it is in bootloader mode. Makefile for Arduino Esplora project takes care of this.

References

Arduino CLI - Sketch build Process
Arduino AVR core : github
Arduino-Makefile by Sudar - github
Introduction to Bare Metal Programming in Arduino Uno - hackster post by Milani Stefano
AVR-Debug by Jan Dolinay - github
AVR-GCC cross toolchain for windows (includes make, avrdude and avr-gdb) - Zak's Electronics blog
AVRDUDE - github
SimplySerial (command line serial terminal) - github
A Simple Makefile Tutorial
Managing Projects with GNU Make, Third Edition - Free Book - O'Reilly Open Books Project
Makefile for projects having source files located in multiple directories - Stackoverflow
Calling makefile form another makefile - Stackoverflow

Compile Arduino Sketches with Makefile

Compile, upload and debug arduino sketches with makefile