Ready to start with AportelliHadrons Hadrons v14 to unlock precision from day one. The design integrates fermions, energy-efficient block workflows, and a clean-up path that minimizes downtime. This version emphasizes a streamlined upgrade to keep your runs fast and reliable.

Follow the readmemd guidance on github to explore features, branch strategy, and release notes. Create a branch for your integration, run a test locally, and plan the merge with the main line. christoph leads the QA plan and functions are documented to help please teams validate quickly and avoid regressions.

Changes introduce tighter controls in the scheduler, with test suites that cover 1k+ scenarios. If a broken dependency arises, the bugfix patch flows through CI runs and is ready for merge after code review. Maintain traceability with a changelog and start a new branch for every feature.

Above all, you gain a modular functions layer for seamless integration with your stack, plus new changes to memory management and scheduling. The system supports hot-swapping modules without downtime, enabling teams to ship updates without disrupting active simulations. The value stays above baseline performance as you scale across nodes.

For teams, please consult the readmemd for deployment steps, and rely on github issues to track bugs that are being addressed. This approach keeps stakeholders informed and accelerates adoption across different branch paths and runs.

PackageCompiler integration options in Hadrons v14: which modes to use

Modes you can enable in Hadrons v14

Use on-demand prebuild mode for day-to-day development. It compiles packages as they are loaded and stores results in the user cache, keeping startup quick and memory usage predictable.

For automated tests and demos, switch to a bundled prebuilt image mode. This ships with commonly used packages already prepared, delivering very fast startup and stable behavior across runs. Keep the image lightweight by excluding rarely used packages and provide a script to refresh it when core APIs change.

To maintain CI determinism, pin package versions and enforce a clean-up policy that prunes old artifacts. Add a lightweight verification step that loads a representative workload and checks for compatibility after updates. If a mismatch is detected, trigger a quick patch/build cycle and archive the failing artifacts for traceability.

How to implement in your workflow

In your Hadrons v14 build script, toggle PackageCompiler mode with a simple environment variable. This lets developers test both paths without code changes.

Include clear steps to invalidate caches and revert to on-demand mode when needed. Provide a compact guide for cleaning up stale artifacts and validating compatibility against the current Julia/runtime version.

Step-by-step: enabling PackageCompiler in a new Hadrons v14 project

Please add PackageCompiler to the new Hadrons v14 project by running Pkg.add("PackageCompiler") in the Julia REPL and committing the change to the Project.toml file. This ensures the module is available in the packages list and helps avoid deflation of startup time in the most common configurations.

Prerequisites

Confirm you work on Julia 1.9+ and that the Hadrons v14 baseline is checked out above in the repository. Create a clean clone on github to keep the thread linear, then pull the latest changes. The authors fabian and rchrhill have historically contributed fixes and bugfix PRs; credit them in the commit message to ease merge.

In the project, add a small build_sysimage.jl script that loads PackageCompiler and calls PackageCompiler.compile for the most-used modules. Place the produced sysimage into a dedicated files/compiled folder and reference it in the runtime path. After running the script, monitor memory usage to catch any deflation risks and confirm a timing improvement. Run Pkg.instantiate() and Pkg.precompile() to lock in dependencies and avoid aderrors in production.

Verification

Launch Hadrons v14 with the new sysimage and run a test thread that exercises core paths, including fermions and module access. If you observe a reduction in load times and no missing modules, the implementation is solid. Check the logs for aderrors or broken warnings; if this happens, apply a bugfix commit and re-run the test. Document the results in the packages list and reference the patch in the commit message.

When this is stable, push to github, open a pull request, and merge the featurebatch into main. Update the files touched in the block to keep the history clean and ensure the most important changes are portable across environments. This approach yields a reliable baseline for future fixes and improvements.

How to verify compilation success and runtime behavior after enabling PackageCompiler

Start with a clean environment and a fresh sysimage by rebuilding PackageCompiler outputs. Clear zeros in caches, remove extratypicaljl traces, and ensure no broken modules were replaced by stale builds. Build the sysimage to include the target packages, then run a focused test to confirm both compilation success and runtime behavior. This approach keeps the verification precise and traceable. please proceed with a small, iterative cycle to tighten confidence.

Recommended verification workflow

Create a dedicated branch (for example bugfix/PackageCompiler) on GitHub, commit the changes, and push to your repository; this enables a clear merge path and review of the aderrors and related fixes. Prepare a list of modules to precompile, including the core file and the packages you rely on, such as fermions, clover, and joswig; verify that each entry is loaded into the sysimage without replacement. Build the sysimage into a new file, run Julia with that sysimage, and execute a representative set of test functions that cover the most common workflows. Run multiple test nodes or runs to observe consistency across environments, and compare results against the previous branch to identify regressions. If you see precompile_aderrorsjl or related aderrors, switch to a bugfix branch, implement the fix, and re-run the verification cycle. When the results stabilize, merge the branch and tag the commit for traceability. In most cases, this path will expose both compilation paths and runtime behavior, and you can rely on a straightforward, iterative pattern.

Diagnostics and interpretation

When compilation succeeds, you will see fast module loading and quick function dispatch after the first run; if trace logs show stable loading sequences for modules like clover or mbruno-eclover, you are on the right track. If a case reports broken precompilation or aderrors persist, inspect the precompile_aderrorsjl log and the corresponding file entries to identify replaced files or missing dependencies. If a trace reveals extratypicaljl artifacts, backtrack to the commit that introduced the change, verify the affected modules, and adjust the implementation before re-running the test suite. For fermions and other physics-oriented functionality, verify that the most critical routines–such as the core functions and test cases–produce consistent outputs across runs, and verify zero-difference results after precompilation. When most tests pass, proceed to clean-up and prepare the merge; if a failure occurs, isolate it in the bugfix branch and implement a targeted fix, then re-run and compare results. This disciplined cycle reduces risk and provides a clear path from local verification to GitHub merge.

Step Action Expected result
Branch setup Create a bugfix/PackageCompiler branch, commit changes, push to GitHub, open PR PR demonstrates traceability; branch shows a clean history for merge
Sysimage build List modules and packages (file, modules, packages) and run create_sysimage Sysimage file builds without aderrors; precompile traces complete
Initial run Launch Julia with the new sysimage and run a test set for functions Most functions execute correctly; runtimes are stable across runs
Diagnostics Inspect precompile_aderrorsjl and trace outputs for replaced or broken modules No aderrors; trace shows consistent module loading (joswig, clover, mbruno-eclover)
Bugfix cycle If issues appear, implement a bugfix, commit, and retry test runs Errors resolved; tests pass with clean-up of extratypicaljl paths
Merge readiness Ensure all tests pass, merge PR, and tag the commit Stable, reproducible verification across environments

System requirements and platform compatibility for Hadrons v14

Choose Linux x86_64 with AVX2 and at least 16 GB RAM, use prebuilt packages for a quick deployment, then run the rrhodgson analysis to validate the setup. For custom builds, follow the source path and keep a clean separation between build and runtime folders. Ensure case,this,file naming conventions are followed when packaging; this helps reproducibility by avoiding zeros in paths.

Platform support and runtime

Build, packages, and deployment workflow

File map: key components in Hadrons v14 and what to customize

Recomendación: Start by mapping the key components in Hadrons v14 and tailor their defaults to your workflow; this keeps changes focused and traceable.

Core kernel Map the computation kernel for Hadrons v14, enable multiplication across fermions, and align with readmemd definitions to ensure a stable baseline. Watch for broken paths and use trace logs to identify bottlenecks. Keep the configuration lean to support most workloads and avoid drift.

Feature map: fjoswfeatureeclover Turn on the fjoswfeatureeclover flag to enable Clover-inspired optimizations while preserving compatibility with joswig logic. This helps reduce aderrors and improves contraction correctness in edge cases. Use the merge mechanism to integrate with the main path without breaking runtime.

Data path and initialization Align data shapes by initializing zeros where needed, apply index contraction rules, and ensure the path can merge into existing pipelines. Document the changes in readmemd so teammates understand the rationale.

Diagnostics and debugging Enable trace of critical components, collect list of events, and standardize messages for easier debugging. Apply bugfix patches as soon as aderrors appear, and track case studies to prevent regression.

Lifecycle: replacements and updates When a module is replaced, map the case transitions and use this to keep references intact. Implement and develop new functions with clear tests and a rollback path. Note dependencies to avoid cascading failures.

Interop and integration Align with external tools via merge into the main build, preserve compatibility in the this context, and coordinate with teams labeled rchrhill and mbruno-eclover. Use joswig interfaces for cross-module signals and maintain end-to-end traceability.

Documentation and knowledge Keep a living entry in readmemd about the most critical components and their customization knobs. Include examples and pitfalls to help new developers start quickly.

Most actionable steps Please implement a three-phase plan: map, adjust, verify. Start with the core kernel, enable the Clover toggle, and validate with a small test harness. Monitor trace outputs, confirm zeros are not leaking, and ensure multiplication results match expectations for fermions. Report any anomalies with a concise message for faster triage.

GitHub resources: Fjosw Fabian Joswig, Files, and contributor guidelines

Start by forking the repository, then clone it locally. Create a branch named featurebatch/fjoswfeatureeclover aligned into develop, implement the change, and push. Open a pull request and invite reviews with nelsonlachini, jprichings, or mbruno-eclover as appropriate. In the PR description, reference related issues and provide a concise commit message that explains the intent, e.g., "fixes: correct trace path in precompile_aderrorsjl" or "first pass on file handling".

Keep commits focused: use this pattern, commit message prefix with a verb, describe the changes, and mention the file or case touched. For example, a commit that fixes the multiplication logic in a slow test, or updates test data for zeros. When you push, ensure you attach the change set to the branch and ask for review. Please run the precompile_aderrorsjl script as part of your checks, and trace the behavior across different runs and case scenarios. If you need to adjust, commit additional changes; this is being expected in collaborative workflows.

Files, checks, and collaboration

On the Files tab, add a concise analysis of changes and their impact on builds. Run the analysis to confirm no regressions in the core logic, especially for the multiplication and zeros cases. Use the trace output to document how the code behaves under various runs. If failures occur, revert or add fixes, and push a new commit to the featurebatch, continue to iterate until the checks pass. For collaboration, reference contributors like nelsonlachini, jprichings, fjosw, and mbruno-eclover, keeping communication constructive and on-topic. Please keep the branch name stable and avoid cluttering the history with minor tweaks.