Can you write github workflow files to generate executable files on the windows and linux platforms

[winezer0]

Can you write github workflow files to generate executable files on the windows and linux platforms

I tried to write but failed

[Cyberphoenix518]

I’ll help you create GitHub Actions workflow files to generate executable files for both Windows and Linux platforms. Since you mentioned you tried and failed, I’ll keep the solution straightforward, robust, and well-documented, assuming you’re working with a programming language like C++ (a common choice for cross-platform executables). If you’re using a different language (e.g., Python, Rust, Go), please let me know, and I can adjust the workflows accordingly. I’ll also address common pitfalls, such as missing DLLs on Windows or incorrect executable paths, based on known issues from web resources.

The workflows will:

Compile a simple C++ program into executables for Windows (.exe) and Linux.
Use a matrix strategy to run builds on both platforms in parallel.
Upload the resulting executables as artifacts for easy download.
Below, I’ll provide two artifacts: one for the C++ source code and one for the GitHub Actions workflow file. I’ll also include a basic Makefile to simplify compilation.

Assumptions
You have a C++ project with a single source file (main.cpp).
You’re using g++ for compilation on both platforms.
The project is hosted in a GitHub repository.
You want to generate native executables (not a single cross-platform binary, as that’s not feasible for C++ without complex solutions like Cosmopolitan).
You’re using GitHub-hosted runners (windows-latest and ubuntu-latest).
Artifacts

1. C++ Source Code
   This is a simple "Hello, World!" program to demonstrate compilation. You can replace it with your actual code.

main.cpp
x-c++src
Show inline
2. Makefile
This Makefile defines rules to compile the C++ code into an executable, handling platform-specific naming (.exe for Windows).

Makefile
x-makefile
Show inline
3. GitHub Actions Workflow
This workflow:

Triggers on push or pull request to the main branch.
Uses a matrix to build on windows-latest and ubuntu-latest.
Compiles the code using the Makefile.
Runs the executable to verify it works.
Uploads the executable as an artifact, named according to the platform.
.github/workflows/build.yml
yaml
Show inline
Explanation of the Workflow
Matrix Strategy:
The matrix.os defines two runners: ubuntu-latest and windows-latest.
The include block specifies platform-specific variables:
artifact_name: Names the artifact (e.g., myprogram-linux or myprogram-windows).
executable: Specifies the path to run the executable (e.g., ./myprogram for Linux, .\myprogram.exe for Windows).
Steps:
Checkout: Clones the repository.
Set up environment:
For Linux: Installs g++ using apt-get.
For Windows: Uses msys2/setup-msys2 to set up a MinGW environment with g++, avoiding common DLL issues seen with windows-latest.
Compile: Runs make build, passing the OS environment variable to the Makefile to handle platform-specific naming.
Run: Executes the compiled program to verify it works, using the platform-specific path.
Upload artifact: Saves the executable as a downloadable artifact, retained for 7 days.
Common Pitfalls Addressed:
Windows DLL Issues: Using msys2/setup-msys2 ensures necessary MinGW libraries are available, avoiding errors like exit code -1073741511.
Executable Paths: The Makefile and workflow use platform-specific paths (./ vs .) to prevent "No such file or directory" errors.
Compiler Availability: Explicitly installs g++ on both platforms to ensure consistency.
How to Use
Set Up Your Repository:
Create a GitHub repository or use an existing one.
Add the main.cpp and Makefile files to the root directory.
Create a .github/workflows/ directory and add the build.yml file.
Push to GitHub:
Commit and push the files to the main branch.
The workflow will trigger automatically.
View Results:
Go to the repository’s “Actions” tab on GitHub.
Select the workflow run and check the logs for each job (build on Linux and Windows).
Download the artifacts (myprogram-linux and myprogram-windows) from the workflow summary.
Testing the Executables
Linux: Run the downloaded myprogram on a Linux system (e.g., ./myprogram). Ensure it’s executable (chmod +x myprogram).
Windows: Run myprogram.exe on a Windows system. The MinGW setup ensures no external DLLs are required.
If You Encounter Issues
Windows Errors: If you see exit code errors (e.g., -1073741511), ensure the msys2/setup-msys2 action is correctly installing MinGW. Alternatively, try windows-2019 as the runner, as it may include necessary DLLs by default.
Linux Errors: Verify g++ is installed and the executable path is correct. Check the ls output in the workflow logs to confirm the binary’s name.
Different Language: If you’re using Python (e.g., with PyInstaller), Rust, or Go, let me know, and I can provide a tailored workflow (e.g., using pyinstaller-action-windows for Python).
Your Previous Attempt: If you can share details about what failed (e.g., error messages, your workflow file), I can diagnose specific issues.
Notes
The workflow uses windows-latest (Windows Server 2022 as of May 2025) but avoids DLL path issues by using MinGW via msys2.
Artifacts are named distinctly to avoid overwriting, unlike some workflows where repeated uploads cause issues.
The Makefile simplifies cross-platform compilation, but you can modify it for more complex projects.
If you need a single executable for both platforms, that’s not feasible natively with C++, but tools like Cosmopolitan exist for advanced use cases (though they’re complex and not recommended).

Makefile.txt

[vanhauser-thc]

if someone wants to create such a workflow for github to create the windows executables I am open to it. I won't do it myself simply because I do not use Windows