Developer Setup
Set up the Zeta development environment — install prerequisites, restore dependencies, build, test, and run the Godot application.
Set up the development environment
Set up a complete Zeta development environment from a clean clone, validate the solution, and run the Godot application locally.
Prerequisites
Install the following tools before cloning and building Zeta:
- .NET SDK
10.0.401 - Godot
4.7.2 .NET - Git
- Windows 10 or Windows 11
The persistent application targets Windows. On other platforms, use the isolated --smoke-test or --demo-preview modes instead of normal application execution.
Setup flow
Clone the repository
Clone the repository and change to its directory:
git clone https://github.com/PNY92/zeta.git
cd zeta
The repository root contains Zeta.slnx, the source projects, tests, scripts, and documentation.
Verify the .NET SDK
Check the installed SDK:
dotnet --version
The command must print:
10.0.401
Zeta pins this SDK version in global.json with roll-forward disabled. Install the pinned version before continuing if the command reports a different version.
Restore dependencies
Restore the locked NuGet dependency graph:
dotnet restore Zeta.slnx --locked-mode
A successful restore completes without changing the lock files. If restore fails because the lock files are out of date, do not bypass locked mode. Review the dependency change before updating them.
Build the solution
Build every project in the solution without restoring again:
dotnet build Zeta.slnx --no-restore -m:1
The build compiles the domain, infrastructure, Godot application, and test projects. A successful build ends with a succeeded build summary and no errors.
Run the tests
Run the integration and integrity tests against temporary SQLite stores:
dotnet test tests/Zeta.Tests/Zeta.Tests.csproj --no-build --no-restore
The test project exercises persistence, encryption, concurrency, idempotency, recovery, state transitions, and synthetic delivery behavior. A successful run reports that all tests passed.
Open the project in Godot
Open Godot 4.7.2 .NET and import:
src/Zeta.Godot/project.godot
Run the project from the Godot editor. The main scene is Main.tscn, and the application opens in the synthetic warehouse workspace.
Run the isolated smoke test
Run the end-to-end smoke test from the repository root:
godot --headless --path src/Zeta.Godot -- --smoke-test
The smoke test uses an isolated temporary workspace, exercises a real application flow, creates an encrypted snapshot, and exits after printing:
ZETA_SMOKE_OK
Development builds run an additional smoke test that verifies configuration loading, fixture replay, and the Settings JSON editor. A successful Development smoke test prints ZETA_DEVELOPMENT_SMOKE_OK in addition to ZETA_SMOKE_OK.
Validate the complete environment
The validation script runs the standard checks in one command:
.\scripts\Validate.ps1
Use scripts/Validate.ps1 before opening a pull request. The script runs locked dependency restore, a full solution build, xUnit tests, Godot headless import, and the Godot headless smoke test.
Export a Windows build
Use the export script to create the Windows prototype package:
.\scripts\Export-Windows.ps1
The script restores the Windows x64 export dependencies in locked mode, imports the Godot project, performs a Windows release export, verifies that Zeta.Godot.dll and e_sqlite3.dll are present, copies license and notice files, and creates RUN-PROTOTYPE.txt.
The export is unsigned and must remain distributed as a complete folder.
Development export
To export a Development build, pass the -BuildEnvironment parameter:
.\scripts\Export-Windows.ps1 -Godot $env:GODOT -BuildEnvironment Development
The Development export uses the Windows Development Godot preset, writes to artifacts/windows-development/, and includes development.json and DEVELOPMENT.md alongside the executable.
Package the export
After exporting, create a distributable ZIP archive with a SHA-256 checksum:
.\scripts\Package-Windows.ps1 -Version v0.1.0
The script validates that the exported directory contains the executable, PCK, runtime, SQLite native library, required notices, and license files before creating:
artifacts/release/Zeta-v0.1.0-windows-x64.zip
artifacts/release/Zeta-v0.1.0-windows-x64.zip.sha256
Development packages are created the same way:
.\scripts\Package-Windows.ps1 -Version v0.1.0 -BuildEnvironment Development
This produces:
artifacts/release-development/Zeta-v0.1.0-windows-x64-development.zip
artifacts/release-development/Zeta-v0.1.0-windows-x64-development.zip.sha256
Automated CI builds and releases
The repository includes a CI workflow that automatically builds, tests, and packages the Windows x64 export on every pull request and push to main. Non-release runs upload the package as a GitHub Actions artifact.
Pushing a version tag publishes a GitHub prerelease with the Windows package:
git tag v0.1.0
git push origin v0.1.0
Supported tag formats are vMAJOR.MINOR.PATCH and vMAJOR.MINOR.PATCH-suffix (for example, v0.1.0-rc.1). The release includes the ZIP package and a SHA-256 checksum file. A failed build or validation prevents publication, and published releases cannot be overwritten.
Project structure
The solution is organized into four primary projects:
Zeta.Core: Domain entities, business rules, state transitions, service interfaces, and application workflows.Zeta.Infrastructure: EF Core, SQLite persistence, encryption, migrations, and synthetic adapters.Zeta.Godot: Godot scenes, application startup, user interface, and warehouse visualization.Zeta.Tests: xUnit integration and integrity tests using real temporary SQLite databases.
Zeta.slnx is the repository-wide solution file used for restore, build, and solution-level development commands.