v2.24.1.20260816

xhdfe 2.24.1 / xfe 1.11.0 — 16aug2026

Python regression-table integration release. The estimator, fixed-effect
absorber, numerical tolerances, convergence criteria, C++/CUDA kernels, Stata
estimation behaviour, and R estimation behaviour are unchanged from 2.24.0.

Direct maketables integration

Fitted Python results now implement maketables' documented duck-typed plug-in
format. Formula and native array-API fits can be passed directly to ETable
without an adapter, registration step, or new xhdfe runtime dependency:

import maketables as mt
import xhdfe

model = xhdfe.feols(
    "y ~ x1 + x2 | firm + year",
    data=d,
    se_type="cluster",
    clusters="firm",
)
print(mt.ETable([model], drop="Intercept").make(type="tex"))

The integration exposes coefficient estimates, standard errors, t statistics,
p-values, dependent-variable and fixed-effect metadata, variance-estimator
information, variable labels, and the following model statistics: N, r2,
r2_within, rmse, n_clusters, se_type, N_full, n_singletons, and
df_absorbed.

Formula fits retain canonical cluster names, standard-error type, and a
read-only snapshot of supported dataframe variable labels. Array-API fits use
positional coefficient names and explicit generic fixed-effect labels when no
formula metadata exists, so an absorbed dimension is never silently hidden.

Confidence-interval plug-in tokens are deliberately omitted. xhdfe supports an
arbitrary confidence level and must not label a non-95% interval as ci95l or
ci95u. Existing confidence intervals remain available through the normal
xhdfe result interface.

The hook attachment is idempotent and transactional. Failure to attach optional
table descriptors cannot leave a partially modified result class or prevent the
native estimator from loading.

Packaging and validation

The release workflow pins maketables==0.1.8 for the integration gate and
requires the new module and tests in wheels, Python source distributions, and
the autonomous source archive. The base package still does not depend on or
import maketables.

Local acceptance covered 116 repository tests and 67 formula/maketables tests,
including end-to-end ETable rendering for formula and array results. A
deterministic before/after estimator payload remained byte-identical, with
convergence and iteration count unchanged.

Contribution credit

This feature was proposed and initially implemented by
@fqueiro in
public PR #7. The released
implementation adapts that contribution to xhdfe's confidence-level semantics,
native array metadata, transactional attachment, and release-artifact gates.

Version scope

No R or Stata estimation feature is added by this Python integration. Their
metadata are restamped only to preserve the unified release identity:

• shared C++/Python/R package and release tag: 2.24.1.20260816;
• Stata xhdfe, xhdfe_p, xhdfe_estat, and xhdfegpu: 2.24.1;
• Stata xfe: unchanged at 1.11.0;
• other production ado feature versions: unchanged;
• production Stata text files listed by xhdfe.pkg/xfe.pkg: common release
  date 16aug2026.

Certification boundary

Local source tests are prerequisites, not publication approval. A preflight tag
must build and assemble every exact artefact. The version tag creates a draft
release only. Publication remains blocked until the exact CI CUDA bundle passes
CPU/CUDA functional validation, real-use diagnostics, numerical parity, and the
large OpenMP regression gate on the maintainer H100. Only the matching
publish-v* marker may publish that draft and its net-install snapshot.

---

Release assets and installation

Stata plugins built automatically on GitHub-hosted runners.

GitHub-hosted CI imports and exercises the Python wheels and runs
R CMD check. For the Stata plugins it proves COMPILE + LINK only:
the runners have no Stata license, and they have no GPU for CUDA
runtime validation. The workflow initially stages this release as a
draft and permits publication only after the exact plugins contained in
the attached Linux CUDA bundle pass
Stata CPU/CUDA functional validation on real hardware (an NVIDIA H100,
sm_90). A published release therefore records completion of that
external gate.

Online Stata install

The publish-v* gate publishes the exact H100-certified snapshot to
gh-pages. Stata can install the OS-appropriate plugin from one URL:

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines:
Linux installs the portable CPU/OpenMP plugin, macOS installs the
universal CPU plugin, and Windows installs the Windows plugin when that
build artifact exists.

Assets

Per-platform Stata bundles (plugin renamed to canonical xhdfe.plugin / xfe.plugin + shared ado/sthlp/pkg/stata.toc)

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP (portable ELF, links libgomp; no -march=native).
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64, CUDA fatbin (SASS sm_75/80/86/89/90 + compute_90 PTX; incorporates the static CUDA runtime/device runtime and dynamically links libgomp). CI compile-verifies this path; publication additionally requires the external H100 runtime gate.
• xhdfe_xfe-stata-windows-cpu.zip — Windows x86_64, CPU/OpenMP (PE32+ plugins plus their validated MinGW runtime closure; intended for 64-bit Windows 10/11).
• xhdfe_xfe-stata-macos-universal.zip — macOS universal (x86_64 + arm64), CPU (Mach-O bundle, no OpenMP). Unsigned/unnotarized: end users may need xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin before Stata loads them.

Python and R packages

• xhdfe-2.24.1.20260816-*manylinux*.whl — Linux x86_64 CPU
  wheel, installed and exercised from an isolated environment in CI.
• xhdfe-2.24.1.20260816-*win_amd64.whl — Windows x86_64 CPU
  wheel built with Strawberry MinGW; its GNU runtime DLL closure is
  inspected and import-tested with Strawberry removed from PATH.
  Use the source distribution on other systems or Python ABIs.
• xhdfe-2.24.1.20260816.tar.gz — Python source distribution.
• xhdfe_2.24.1.20260816.tar.gz — R source package.

Offline source bundle

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged
  sources, vendored offline build inputs, and the exact Linux CPU/CUDA,
  Windows x86_64 OpenMP, and macOS universal plugins from this workflow.
• xhdfe-2.24.1.20260816-corresponding-source.zip — exact
  GNU/MinGW runtime sources, distribution patches/build recipes,
  provider source packages, license texts, and byte-level provenance
  for the runtime libraries carried by the release artifacts.

Online net-install site snapshot

• xhdfe_xfe-stata-netinstall-site.zip — the exact stata/ tree published to gh-pages for online net install.

Integrity

• SHA256SUMS.txt — SHA-256 digest for every separately downloadable release asset.

Build matrix

Platform	Backend	Runner	Notes
Linux x86_64	Stata CPU/OpenMP	ubuntu-latest	portable, libgomp-linked
Linux x86_64	Stata CUDA fatbin	ubuntu-latest	sm_75/80/86/89/90 + compute_90 PTX; CI compile-verified, published release H100-certified externally
Linux x86_64	Python CPU wheel	manylinux_2_28 + ubuntu-latest	repaired manylinux wheel; clean installed-wheel formula smoke
Windows x86_64	Stata CPU/OpenMP	ubuntu-latest (mingw POSIX cross)	PE32+ plugins + validated colocated runtime DLL closure; intended for Windows 10/11
Windows x86_64, CPython 3.12	Python CPU/OpenMP wheel	GitHub-hosted Windows x86-64 (Strawberry MinGW 5.42 / GCC 13.2)	generic recursive non-system DLL closure; intended for Windows 10/11; import and formula smoke without Strawberry on PATH
macOS x86_64+arm64	Stata CPU	macos-14	universal bundle, no OpenMP

v2.24.0.20260815

xhdfe 2.24.0 / xfe 1.11.0 — 15aug2026

Python interface and Windows packaging release. The estimator, fixed-effect
absorber, numerical tolerances, convergence criteria, C++/CUDA kernels, Stata
estimation behaviour, and R estimation behaviour are unchanged from 2.23.1.

Optional Python formula interface

Python now offers an additive R/Formulaic-style frontend while retaining the
existing low-overhead array API:

model = xhdfe.feols(
    "y ~ x1 + x2 + C(industry) | firm + year",
    data=d,
    se_type="cluster",
    clusters="firm",
)

• C(g) supplies treatment-coded categorical regressors.
• x:z is a product-only interaction; x*z expands to both main effects and
  their interaction.
• I(x**2) requests an arithmetic square.
• Fixed effects after | are encoded as group identifiers and passed to the
  native absorber, not expanded into a dense dummy matrix.
• Weights, frequency weights, one- or multiway clusters, explicit transform
  contexts, result names, source/estimation indices, and tidy() are supported.
• prepare_formula() creates a read-only design snapshot for repeated fits.

The frontend follows Formulaic semantics rather than adding a second Stata
parser. In particular, C(g):x with an intercept contains one explicit slope
per category and is not the same model as standalone Stata i.g#c.x.

Formulaic (formulaic>=1.2.1,<2) and pandas (pandas>=1.3) are an optional,
lazy-loaded formula extra. Base imports and the array API do not import that
stack. From a source checkout:

python -m pip install '.[formula]'

The release workflow publishes Python packages as GitHub Release assets; it
does not claim a PyPI publication. Formulaic/pandas/SciPy are not vendored in
the autonomous offline archive and must already be available in an offline
Python environment.

Formula performance

Simple numeric formulas use a direct NumPy materialisation path. The fixed
parsing cost matters most for very small regressions; a prepared formula avoids
that repeated cost and keeps loop use close to the pre-built-array route. The
array API remains the preferred zero-overhead interface. Numerical and sample
parity are release-tested against manually constructed arrays.

Generic Windows runtime closure

When CMake selects GNU/MinGW on Windows, the build inspects the resulting
.pyd, resolves every non-system PE dependency recursively, and copies the
validated closure beside the extension. The resolver is dependency-driven,
not a list of five Strawberry filenames: missing, ambiguous, unlicensed,
wrong-architecture, conflicting, or unreferenced DLLs fail the build.

The wheel embeds a manifest containing the PE graph, architecture, size,
SHA-256, provider path, provider SHA-256, resolution method, and licence family
for every runtime. The release validator independently reconstructs the graph
from direct wheel members. Before loading the native extension, xhdfe registers
the installed package directory with os.add_dll_directory() and retains the
handle for the lifetime of the process.

The prebuilt Windows asset targets CPython 3.12 x86-64. It is built on a
GitHub-hosted Windows x86-64 runner with Strawberry Perl 5.42.0.1 / GCC 13.2,
with machine-specific instruction tuning disabled. Windows source builds also
default to portable tuning; an explicitly local-only build can opt in. The
clean-environment gate removes Strawberry from PATH and exercises the base,
legacy, and formula imports. Other Python ABIs use the source distribution and
are not separately Windows-certified in this release.

The Stata Windows bundle uses the same closure principle: its plugin roots,
runtime directory, and ledgers must describe exactly one reachable PE graph;
the online package generates one g WIN64 entry per validated DLL.

Runtime provenance and licence materials

Release artefacts that carry GNU/MinGW runtime libraries also carry the exact
applicable GCC Runtime Library Exception, winpthreads, and dlfcn-win32 licence
texts. The adjacent
xhdfe-2.24.0.20260815-corresponding-source.zip release asset contains the
exact upstream sources, distribution patches/build recipes, provider source
packages, and a byte-level mapping from every released runtime to its provider.

The CUDA bundle records the exact nvcc link invocations and rejects NVIDIA
libraries beyond the static CUDA runtime/device runtime used by the plugins.
It carries the CUDA 12.6 EULA and CCCL 2.5.0 licence materials; NVIDIA inputs
are not represented as GNU Corresponding Source. The Linux wheel separately
maps its auditwheel-private libgomp member to the exact provider and source
RPM.

These custody controls are additive packaging changes; they do not change the
estimator or its backend selection.

R and Stata scope

No R or Stata estimation feature was added for this Python-only frontend. R
already has a formula interface with factors and interactions; Stata already
has factor-variable notation. Their metadata are restamped only to preserve
the unified release identity:

• shared C++/Python/R package and release tag: 2.24.0.20260815;
• Stata xhdfe, xhdfe_p, xhdfe_estat, and xhdfegpu: 2.24.0;
• Stata xfe: unchanged at 1.11.0;
• other production ado feature versions are unchanged;
• production Stata text files listed by xhdfe.pkg/xfe.pkg: common release
  date 15aug2026.

Certification boundary

Source-level tests and local package checks are prerequisites, not release
approval. A preflight tag must build and assemble every exact artefact. The
version tag creates a draft only. Publication remains blocked until the exact
CI CUDA bundle passes Stata CPU/CUDA functional validation and the large
OpenMP regression gate on the maintainer H100. Only the matching publish-v*
marker may publish that draft and its net-install snapshot.

---

Release assets and installation

Stata plugins built automatically on GitHub-hosted runners.

GitHub-hosted CI imports and exercises the Python wheels and runs
R CMD check. For the Stata plugins it proves COMPILE + LINK only:
the runners have no Stata license, and they have no GPU for CUDA
runtime validation. The workflow initially stages this release as a
draft and permits publication only after the exact plugins contained in
the attached Linux CUDA bundle pass
Stata CPU/CUDA functional validation on real hardware (an NVIDIA H100,
sm_90). A published release therefore records completion of that
external gate.

Online Stata install

The publish-v* gate publishes the exact H100-certified snapshot to
gh-pages. Stata can install the OS-appropriate plugin from one URL:

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines:
Linux installs the portable CPU/OpenMP plugin, macOS installs the
universal CPU plugin, and Windows installs the Windows plugin when that
build artifact exists.

Assets

Per-platform Stata bundles (plugin renamed to canonical xhdfe.plugin / xfe.plugin + shared ado/sthlp/pkg/stata.toc)

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP (portable ELF, links libgomp; no -march=native).
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64, CUDA fatbin (SASS sm_75/80/86/89/90 + compute_90 PTX; incorporates the static CUDA runtime/device runtime and dynamically links libgomp). CI compile-verifies this path; publication additionally requires the external H100 runtime gate.
• xhdfe_xfe-stata-windows-cpu.zip — Windows x86_64, CPU/OpenMP (PE32+ plugins plus their validated MinGW runtime closure; intended for 64-bit Windows 10/11).
• xhdfe_xfe-stata-macos-universal.zip — macOS universal (x86_64 + arm64), CPU (Mach-O bundle, no OpenMP). Unsigned/unnotarized: end users may need xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin before Stata loads them.

Python and R packages

• xhdfe-2.24.0.20260815-*manylinux*.whl — Linux x86_64 CPU
  wheel, installed and exercised from an isolated environment in CI.
• xhdfe-2.24.0.20260815-*win_amd64.whl — Windows x86_64 CPU
  wheel built with Strawberry MinGW; its GNU runtime DLL closure is
  inspected and import-tested with Strawberry removed from PATH.
  Use the source distribution on other systems or Python ABIs.
• xhdfe-2.24.0.20260815.tar.gz — Python source distribution.
• xhdfe_2.24.0.20260815.tar.gz — R source package.

Offline source bundle

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged
  sources, vendored offline build inputs, and the exact Linux CPU/CUDA,
  Windows x86_64 OpenMP, and macOS universal plugins from this workflow.
• xhdfe-2.24.0.20260815-corresponding-source.zip — exact
  GNU/MinGW runtime sources, distribution patches/build recipes,
  provider source packages, license texts, and byte-level provenance
  for the runtime libraries carried by the release artifacts.

Online net-install site snapshot

• xhdfe_xfe-stata-netinstall-site.zip — the exact stata/ tree published to gh-pages for online net install.

Integrity

• SHA256SUMS.txt — SHA-256 digest for every separately downloadable release asset.

Build matrix

Platform	Backend	Runner	Notes
Linux x86_64	Stata CPU/OpenMP	ubuntu-latest	portable, libgomp-linked
Linux x86_64	Stata CUDA fatbin	ubuntu-latest	sm_75/80/86/89/90 + compute_90 PTX; CI compile-verified, published release H100-certified externally
Linux x86_64	Python CPU wheel	manylinux_2_28 + ubuntu-latest	repaired manylinux wheel; clean installed-wheel formula smoke
Windows x86_64	Stata CPU/OpenMP	ubuntu-latest (mingw POSIX cross)	PE32+ plugins + validated colocated runtime DLL closure; intended for Windows 10/11
Windows x86_64, CPython 3.12	...

v2.23.1.20260806

xhdfe / xfe — v2.23.1.20260806

Stata plugins built automatically on GitHub-hosted runners.

CI itself proves COMPILE + LINK only. GitHub runners have no GPU
and no Stata license. The workflow initially stages this release as a
draft and permits publication only after the exact attached CUDA fatbins
pass Stata-functional validation on real hardware (an NVIDIA H100,
sm_90). A published release therefore records completion of that
external H100 gate.

Online Stata install

The publish-v* gate publishes the exact H100-certified snapshot to
gh-pages. Stata can install the OS-appropriate plugin from one URL:

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines:
Linux installs the portable CPU/OpenMP plugin, macOS installs the
universal CPU plugin, and Windows installs the Windows plugin when that
build artifact exists.

Assets

Per-platform Stata bundles (plugin renamed to canonical xhdfe.plugin / xfe.plugin + shared ado/sthlp/pkg/stata.toc)

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP (portable ELF, links libgomp; no -march=native).
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64, CUDA fatbin (SASS sm_75/80/86/89/90 + compute_90 PTX; links libcudart + libgomp). CI compile-verifies this path; publication additionally requires the external H100 runtime gate.
• xhdfe_xfe-stata-windows-cpu.zip — Windows 11 x86_64, CPU/OpenMP (PE32+ plugins plus the required libgomp-1.dll and libwinpthread-1.dll runtime files).
• xhdfe_xfe-stata-macos-universal.zip — macOS universal (x86_64 + arm64), CPU (Mach-O bundle, no OpenMP). Unsigned/unnotarized: end users may need xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin before Stata loads them.

Raw CUDA fatbin plugins (for direct H100 validation and reproducibility)

• xhdfe-linux-cuda.plugin, xfe-linux-cuda.plugin — the same Linux CUDA binaries as in the CUDA bundle, attached standalone.

Python and R packages

• xhdfe-2.23.1.20260806-*.whl — Linux x86_64 CPU wheel, installed
  and exercised from an isolated environment in CI; use the source
  distribution on systems with an incompatible glibc/Python ABI.
• xhdfe-2.23.1.20260806.tar.gz — Python source distribution.
• xhdfe_2.23.1.20260806.tar.gz — R source package.

Offline source bundle

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged
  sources, vendored offline build inputs, and the exact Linux CPU/CUDA,
  Windows 11 x86_64 OpenMP, and macOS universal plugins from this workflow.

Online net-install site snapshot

• xhdfe_xfe-stata-netinstall-site.zip — the exact stata/ tree published to gh-pages for online net install.

Integrity

• SHA256SUMS.txt — SHA-256 digest for every separately downloadable release asset.

Build matrix

Platform	Backend	Runner	Notes
Linux x86_64	CPU/OpenMP	ubuntu-latest	portable, libgomp-linked
Linux x86_64	CUDA fatbin	ubuntu-latest	sm_75/80/86/89/90 + compute_90 PTX; CI compile-verified, published release H100-certified externally
Windows 11 x86_64	CPU/OpenMP	ubuntu-latest (mingw POSIX cross)	PE32+ plugins + colocated OpenMP runtime DLLs
macOS x86_64+arm64	CPU	macos-14	universal bundle, no OpenMP

v2.23.0.20260806

xhdfe / xfe — v2.23.0.20260806

Stata plugins built automatically on GitHub-hosted runners.

CI itself proves COMPILE + LINK only. GitHub runners have no GPU
and no Stata license. The workflow initially stages this release as a
draft and permits publication only after the exact attached CUDA fatbins
pass Stata-functional validation on real hardware (an NVIDIA H100,
sm_90). A published release therefore records completion of that
external H100 gate.

Online Stata install

The publish-v* gate publishes the exact H100-certified snapshot to
gh-pages. Stata can install the OS-appropriate plugin from one URL:

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines:
Linux installs the portable CPU/OpenMP plugin, macOS installs the
universal CPU plugin, and Windows installs the Windows plugin when that
build artifact exists.

Assets

Per-platform Stata bundles (plugin renamed to canonical xhdfe.plugin / xfe.plugin + shared ado/sthlp/pkg/stata.toc)

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP (portable ELF, links libgomp; no -march=native).
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64, CUDA fatbin (SASS sm_75/80/86/89/90 + compute_90 PTX; links libcudart + libgomp). CI compile-verifies this path; publication additionally requires the external H100 runtime gate.
• xhdfe_xfe-stata-windows-cpu.zip — Windows 11 x86_64, CPU/OpenMP (PE32+ plugins plus the required libgomp-1.dll and libwinpthread-1.dll runtime files).
• xhdfe_xfe-stata-macos-universal.zip — macOS universal (x86_64 + arm64), CPU (Mach-O bundle, no OpenMP). Unsigned/unnotarized: end users may need xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin before Stata loads them.

Raw CUDA fatbin plugins (for direct H100 validation and reproducibility)

• xhdfe-linux-cuda.plugin, xfe-linux-cuda.plugin — the same Linux CUDA binaries as in the CUDA bundle, attached standalone.

Python and R packages

• xhdfe-2.23.0.20260806-*.whl — Linux x86_64 CPU wheel, installed
  and exercised from an isolated environment in CI; use the source
  distribution on systems with an incompatible glibc/Python ABI.
• xhdfe-2.23.0.20260806.tar.gz — Python source distribution.
• xhdfe_2.23.0.20260806.tar.gz — R source package.

Offline source bundle

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged
  sources, vendored offline build inputs, and the exact Linux CPU/CUDA,
  Windows 11 x86_64 OpenMP, and macOS universal plugins from this workflow.

Online net-install site snapshot

• xhdfe_xfe-stata-netinstall-site.zip — the exact stata/ tree published to gh-pages for online net install.

Integrity

• SHA256SUMS.txt — SHA-256 digest for every separately downloadable release asset.

Build matrix

Platform	Backend	Runner	Notes
Linux x86_64	CPU/OpenMP	ubuntu-latest	portable, libgomp-linked
Linux x86_64	CUDA fatbin	ubuntu-latest	sm_75/80/86/89/90 + compute_90 PTX; CI compile-verified, published release H100-certified externally
Windows 11 x86_64	CPU/OpenMP	ubuntu-latest (mingw POSIX cross)	PE32+ plugins + colocated OpenMP runtime DLLs
macOS x86_64+arm64	CPU	macos-14	universal bundle, no OpenMP

v2.22.1.20260730

xhdfe / xfe — v2.22.1.20260730

Stata plugins built automatically on GitHub-hosted runners.

CI itself proves COMPILE + LINK only. GitHub runners have no GPU
and no Stata license. The workflow initially stages this release as a
draft and permits publication only after the exact attached CUDA fatbins
pass Stata-functional validation on real hardware (an NVIDIA H100,
sm_90). A published release therefore records completion of that
external H100 gate.

Online Stata install

The publish-v* gate publishes the exact H100-certified snapshot to
gh-pages. Stata can install the OS-appropriate plugin from one URL:

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines:
Linux installs the portable CPU/OpenMP plugin, macOS installs the
universal CPU plugin, and Windows installs the Windows plugin when that
build artifact exists.

Assets

Per-platform Stata bundles (plugin renamed to canonical xhdfe.plugin / xfe.plugin + shared ado/sthlp/pkg/stata.toc)

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP (portable ELF, links libgomp; no -march=native).
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64, CUDA fatbin (SASS sm_75/80/86/89/90 + compute_90 PTX; links libcudart + libgomp). CI compile-verifies this path; publication additionally requires the external H100 runtime gate.
• xhdfe_xfe-stata-windows-cpu.zip — Windows 11 x86_64, CPU/OpenMP (PE32+ plugins plus the required libgomp-1.dll and libwinpthread-1.dll runtime files).
• xhdfe_xfe-stata-macos-universal.zip — macOS universal (x86_64 + arm64), CPU (Mach-O bundle, no OpenMP). Unsigned/unnotarized: end users may need xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin before Stata loads them.

Raw CUDA fatbin plugins (for direct H100 validation and reproducibility)

• xhdfe-linux-cuda.plugin, xfe-linux-cuda.plugin — the same Linux CUDA binaries as in the CUDA bundle, attached standalone.

Python and R packages

• xhdfe-2.21.0.20260725-*.whl — Linux x86_64 CPU wheel, installed
  and exercised from an isolated environment in CI; use the source
  distribution on systems with an incompatible glibc/Python ABI.
• xhdfe-2.21.0.20260725.tar.gz — Python source distribution.
• xhdfe_2.21.0.20260725.tar.gz — R source package.

Offline source bundle

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged
  sources, vendored offline build inputs, and the exact Linux CPU/CUDA,
  Windows 11 x86_64 OpenMP, and macOS universal plugins from this workflow.

Online net-install site snapshot

• xhdfe_xfe-stata-netinstall-site.zip — the exact stata/ tree published to gh-pages for online net install.

Integrity

• SHA256SUMS.txt — SHA-256 digest for every separately downloadable release asset.

Build matrix

Platform	Backend	Runner	Notes
Linux x86_64	CPU/OpenMP	ubuntu-latest	portable, libgomp-linked
Linux x86_64	CUDA fatbin	ubuntu-latest	sm_75/80/86/89/90 + compute_90 PTX; CI compile-verified, published release H100-certified externally
Windows 11 x86_64	CPU/OpenMP	ubuntu-latest (mingw POSIX cross)	PE32+ plugins + colocated OpenMP runtime DLLs
macOS x86_64+arm64	CPU	macos-14	universal bundle, no OpenMP

v2.21.0.20260725

xhdfe / xfe — v2.21.0.20260725

Stata plugins built automatically on GitHub-hosted runners.

Release certification

This release is published and H100-certified. The exact CUDA fatbins
attached by workflow run 30182927994
were downloaded without substitution and executed under Stata on an NVIDIA
H100 NVL (sm_90) in an Ubuntu 24.04 ABI environment:

• xhdfe and xfe converged with gpu_used=1, backend cuda, status used;
• the 500,000-observation Gelbach absorbed-target smoke passed CPU/CUDA parity
  within 1e-9, with identity gaps below 1e-8;
• SHA-256 verification passed for all 11 downloadable payloads, every ZIP
  passed integrity testing, and all 2,900 files in the offline bundle passed
  its internal manifest;
• the published gh-pages tree is byte-identical to the attached net-install
  snapshot, and an isolated public net install plus regression/Gelbach smoke
  passed.

The exact public CUDA plugin hashes are:

• xhdfe-linux-cuda.plugin: 09f8b67a3e30f9ae4c5881f4c2589c9d973c79159e4a8ce8456dfe1768a74c03
• xfe-linux-cuda.plugin: 208d35f30d603de395a5fdcb14d9c0602ad0f3df532f3e2595ff405d74598efd

GitHub-hosted CI itself proves compile and link only; the
publish-v2.21.0.20260725 marker records completion of the external runtime
gate above.

Online Stata install

net install xhdfe, from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace
net install xfe,   from("https://raw.githubusercontent.com/reisportela/xhdfe-xfe/gh-pages/stata") replace

The online .pkg files use Stata's platform-specific g lines: Linux installs
the portable CPU/OpenMP plugin, macOS installs the universal CPU plugin, and
Windows installs the Windows/OpenMP plugin and its runtime DLLs.

Assets

Per-platform Stata bundles

• xhdfe_xfe-stata-linux-cpu.zip — Linux x86_64, CPU/OpenMP, portable ELF,
  libgomp-linked, no -march=native.
• xhdfe_xfe-stata-linux-cuda.zip — Linux x86_64 CUDA fatbin, SASS
  sm_75/80/86/89/90 plus compute_90 PTX, externally H100-certified.
• xhdfe_xfe-stata-windows-cpu.zip — Windows 11 x86_64 CPU/OpenMP plugins plus
  libgomp-1.dll and libwinpthread-1.dll.
• xhdfe_xfe-stata-macos-universal.zip — macOS universal x86_64/arm64 CPU
  plugins. They are not notarized; end users may need
  xattr -dr com.apple.quarantine xhdfe.plugin xfe.plugin.

Raw CUDA plugins

• xhdfe-linux-cuda.plugin, xfe-linux-cuda.plugin — the same certified
  Linux CUDA binaries present in the CUDA bundle.

Python and R

• xhdfe-2.21.0.20260725-*.whl — Linux x86_64 CPU wheel, installed and
  exercised in an isolated CI environment.
• xhdfe-2.21.0.20260725.tar.gz — Python source distribution.
• xhdfe_2.21.0.20260725.tar.gz — R source package.

Offline and net-install snapshots

• xhdfe_xfe-offline-source-and-platform-binaries.zip — exact tagged sources,
  vendored offline build inputs, packages, and Linux CPU/CUDA, Windows and
  macOS binaries.
• xhdfe_xfe-stata-netinstall-site.zip — exact stata/ tree published to
  gh-pages.
• SHA256SUMS.txt — SHA-256 digest for every separately downloadable payload.

Build matrix

Platform	Backend	Runner	Certification
Linux x86_64	CPU/OpenMP	ubuntu-latest	compile/link/package checks
Linux x86_64	CUDA fatbin	ubuntu-latest + external H100	compile/link plus real-H100 runtime
Windows 11 x86_64	CPU/OpenMP	ubuntu-latest, MinGW POSIX cross	PE32+ and runtime checks
macOS x86_64+arm64	CPU	macos-14	universal Mach-O checks

v2.20.0.20260723

xhdfe 2.20.0.20260723 — Gelbach post-audit inference and diagnostics

This release closes the actionable conditions of the empirical-utility audit
for xhdfegelbach and adds one inferential extension:
joint-covariance inference for shares normalized by the base coefficient.
The Gelbach estimand, decomposition identity, stacked-GMM conventions,
classification threshold, solver tolerances, convergence criteria, and
standard non-Gelbach xhdfe path are unchanged.

Joint inference for base-coefficient shares

• The public result contract now includes the requested-VCE base covariance,
  Cov(delta, b_base), and Cov(total, b_base).

• shares(base) in Stata and share="base" in Python/R use the complete
  delta-method variance

  Var(delta/b) =
      Var(delta)/b^2
    + delta^2 Var(b)/b^4
    - 2 delta Cov(delta,b)/b^3.
  

• The resulting convention is labelled
  joint_base_covariance_delta_method.

• base_fixed remains available, numerically unchanged, and explicitly
  labelled as descriptive fixed-denominator scaling.

• A requested share with an undefined denominator is missing and emits one
  visible warning; Stata also retains that warning in r(notes).

Identification and finite-sample diagnostics

• Every frontend returns the per-X1 squared residual-norm ratio after
  absorbing the declared fixed effects.
• An X1 column with a ratio in (1e-9, 1e-4] remains in the standard estimand
  but receives a visible, recorded near-FE-collinearity warning. The
  XHDFE_GELBACH_NEAR_COLLINEAR_WARN=0 switch suppresses only that warning;
  it does not change classification or any estimate.
• One-way clustered results return the retained cluster count. Fewer than 30
  clusters triggers a caution note without changing the requested VCE or
  substituting another procedure.
• Results now expose df_base, df_full, and the observed-block full-model
  coefficients (gamma) alongside the existing component and sample
  metadata.
• A saturated full model with no positive residual degrees of freedom raises
  a catchable error rather than returning non-finite inference.

CPU/CUDA contract

• Python and R add an opt-in gpu request matching Stata's Gelbach option.
• All three frontends expose truthful requested/attempted/used/backend/status
  diagnostics and the full-model absorption diagnostics.
• CUDA applies only to the full-model FE-absorption phase. Base regression,
  fixed-effect recovery, component construction, covariance algebra, and
  reporting remain CPU work.
• threads() / num_threads is a per-phase OpenMP cap; phases execute
  sequentially and may use fewer threads.

Documentation and empirical boundaries

• The three help surfaces document the new covariance matrices, warning
  thresholds, cluster and degrees-of-freedom metadata, gamma, GPU status
  fields, and full share=base formula.
• Binary outcomes are explicitly described as linear probability models;
  logit-scale decomposition is a separate estimator.
• Formula/factor notation is not interpreted by the decomposition wrappers.
  Researchers should generate a full-rank numeric indicator/interaction
  matrix, omit the intercept and one reference category, and pass explicit
  named blocks.
• Autonomous release media include the pinned official CRAN source archive
  third_party/Rcpp_1.1.2.tar.gz plus its SHA-256/license provenance, and the
  R documentation gives a network-disabled local-library installation route.
• The examples are described accurately as the standard and absorbed-target
  examples executed in Stata, Python, and R.

This tranche does not add multiway clustering, wild-cluster bootstrap,
common HDFE in both specifications, nonconditional recovered-FE covariance,
IV/LATE allocation, dynamic-panel corrections, nonlinear or distributional
decompositions, Oaxaca/KHB/mediation estimators, or a Stata tidy/export
subcommand.

Version surface

• Shared C++/Python/R package and release tag: 2.20.0.20260723.
• Stata xhdfe: 2.20.0.
• Stata xhdfegelbach: 1.4.0.
• Stata xhdfeakm: 1.7.2 (number unchanged).
• Stata xhdfeconnected: 1.2.1 (number unchanged).
• Stata xfe: 1.10.1 (number unchanged).
• All production Stata files carry the common release date 23jul2026.

All rebuilt-Release, oracle, frontend, artifact, standard-path,
performance-triage, two-repository, packaged-asset, and live net-install gates
passed. Immutable evidence and artifact hashes are recorded in
XHDFEGELBACH_CODEX_POSTAUDIT_REMEDIATION_REPORT_20260723.md; the final
release verdict is GO.

xhdfe 2.19.0.20260720 — state-of-the-art Gelbach decomposition

xhdfe 2.19.0.20260720 — state-of-the-art Gelbach decomposition

This minor release turns xhdfegelbach into a cross-language empirical
workflow for linear coefficient-movement accounting while preserving the
established xhdfe estimator path. It adds a distinct, opt-in constrained
estimand for targets absorbed by fixed effects, richer reporting, and
certification-oriented build guards. Gelbach results remain specification
accounting; the command does not identify causal mediation or mechanisms.

Absorbed-target allocation

• Python absorbed_targets=, R absorbed_targets=, and Stata
  absorbedtargets() implement the same constrained estimand when a declared
  X1 target belongs to the span of an added fixed effect.
• The full-model target coefficient is imposed at zero and labelled
  imposed_zero; it is never presented as an estimated within-FE coefficient.
• The backend fails closed unless every declared target is omitted specifically
  because of the absorbed FEs and every undeclared X1/X2 column is identified.
• The Gelbach summation identity remains exact. The standard estimand and its
  arithmetic branch are unchanged; an A/B oracle found 0 differences in 240
  standard-path output blocks.
• For a declared target, total = b_base - 0 and its covariance is equal by
  construction to the requested base-model covariance. Cluster-FE Monte Carlo
  coverage was 0.952 in 500 repetitions.
• Inference is certified only when clustering matches an FE dimension that
  absorbs every declared target. Unadjusted, robust, or crossed clustering is
  retained for descriptive accounting but emits a prominent warning and an
  explicit invalid-inference status.

Empirical reporting across Python, R, and Stata

• focal / focal() selects displayed coefficients without changing either
  model or any full-precision result.
• Signed component shares support movement, base-coefficient, and explicitly
  labelled fixed-base-denominator conventions. Negative shares and totals above
  100 percent are preserved rather than renormalized.
• Python gelbach.tidy() / gelbach.contrast() and R
  xhdfe_gelbach_tidy() / xhdfe_gelbach_contrast() expose publication-ready
  rows and joint-covariance linear combinations.
• Stata now prints one integrated panel per focal coefficient, marks
  0 (imposed) in the coefficient row, and stores the full matrices and
  metadata in r().
• Cross-frontend metadata now uses one contract: zero-based backend indices,
  presentation names, an absorbed mask, identification status, inference
  status, effective N, and singleton counts.
• Six executable examples cover standard and absorbed-target applications in
  Python, R, and Stata. Help files document every option, result object,
  estimand, covariance layout, example, warning, and deliberate limitation.

Correctness and provenance hardening

• The absorbed-target estimand is checked against an external constrained-LSDV
  Stata oracle, in addition to the established official b1x2 oracle for the
  standard estimand.
• Empty X1 now raises a catchable error in Release builds instead of reaching an
  Eigen assertion or undefined behavior.
• CMake defaults to Release and refuses non-Release production builds unless an
  explicit diagnostic opt-out is supplied. Plugin build scripts independently
  reject live __assert_fail references and missing Linux OpenMP linkage.
• Eigen is pinned to the vendored in-repository 3.4.0 headers; artifact
  provenance no longer depends on a sibling checkout or host installation.
• The local production plugins were rebuilt with -DNDEBUG, -O3,
  -march=native, OpenMP, and H100 sm_90. Public release workflows continue
  to build CPU-only Linux, Windows, and macOS plugins from the identical
  sources on native/declared runners.
• xhdfeakm now reports a bounded count when many non-stayer rows hit the
  unit-leverage guard, preventing diagnostic text from exceeding Stata limits;
  no KSS estimate, tolerance, or convergence decision changed.
• Copyright-restricted local papers under literature/ are now protected by
  .gitignore and are not distributed.

Validation and performance

• Gelbach core oracle, cross-frontend parity, help contract, AKM/KSS validator,
  C++ mirror alignment, complete R suite, and the 28-file Stata suite passed on
  Release artifacts.
• All shipped local artifacts have zero dynamic __assert_fail references;
  both Stata plugins link libgomp, and both local CUDA artifacts contain
  sm_90 only.
• A 500,000-observation CPU/CUDA smoke used the real H100
  (gpu_used=1, backend cuda, status used) and preserved CPU/GPU parity.
• The shared host did not provide a quiet timing window. Five interleaved A/B
  pairs nevertheless excluded a standard-path slowdown of 30 percent or more
  in all unadjusted/cluster, weighted/unweighted CPU and CUDA cells
  (one-sided sign test p=0.03125 per cell). This is a catastrophic-regression
  guard, not a claim that smaller timing differences are absent.

Versions: shared C++/Python/R package 2.19.0.20260720; Stata xhdfe
2.19.0; xhdfegelbach 1.3.0; xhdfeakm 1.7.2;
xhdfeconnected remains 1.2.1; xfe remains 1.10.1. All production Stata
files carry the common release date 20jul2026.

xhdfe 2.18.2 — IV identification hardening

xhdfe 2.18.2.20260715 — fail loudly on unidentified IV designs

This patch release hardens the IV/2SLS surface while preserving the established
reghdfe-compatible estimator path for valid models. It also corrects an R
parity test that compared a non-identified fixed-effect representation instead
of its identified group projection.

IV identification hardening

• Zero, duplicated, exactly collinear, post-FWL rank-deficient and
  underidentified instrument designs now fail before the legacy projection.
• The preflight checks instrument rank, residualized excluded-instrument rank,
  useful first-stage rank, finite cross-products and the post-solve
  normal-equation residual.
• Rank decisions are scale-aware and were tested under column and row
  permutations, rescaling from 1e-12 to 1e12, multiple endogenous
  regressors/instruments, weights, fweights, absorbed fixed effects, controls,
  wide designs and large samples.
• Weak but full-rank and near-rank-but-complete IV designs remain accepted; no
  economic weak-IV cutoff was introduced.
• Release-mode NaN/Inf checks use IEEE-754 bit classification and remain active
  under the existing build flags.

Zero-diff valid path

Models that pass preflight retain the existing arithmetic and solver:
Z'Z, Z'Q, LDLT(Z'Z), solve(Z'Q), then Z * gamma. There is no solver
handoff, polishing step, additional estimation iteration, stopping-rule
change, tolerance relaxation, backend change or output-format change.

The directed 53-case oracle matrix rejected all 22 invalid cases and accepted
all 28 valid cases plus three pre-declared near-threshold cases at 1, 2, 4 and
8 CPU threads. Deterministic valid outputs were bit-identical to 2.18.1.
Real-H100 CUDA cases used the GPU and remained inside the measured A/A
floating-point envelope.

R test rigor

The group-level-outcome fixture has four exact null directions, so its raw
individual fixed effects are not unique. The R parity test now checks the
identified group projection against an independent dense QR oracle while
retaining the existing 1e-9 decomposition accuracy gate. No R package
implementation or estimator tolerance changed.

Validation and performance

• Full core23 x 8: 184/184 runs converged; all 92 CUDA rows used a real GPU.
• Stata certification suite: 26/26 do-files passed.
• R full tests and R CMD check: tests passed, exit code 0.
• CPU and real-H100 CUDA AKM/KSS validators passed; maximum CPU/GPU difference
  remained 1.11e-16.
• ASan/UBSan passed the complete 53-case IV matrix.
• Directed IV timing showed improvements across nearly all cells (up to about
  10%); the sole +0.019% measurement was below A/A noise and not
  reproducible. No reproducible slowdown was found.
• Python/C++, Stata, R and distribution C++ mirrors are byte-aligned.

The rejected ABI-hardening prototype, global fast-math experiments and all
xtwoway work are excluded from this release.

Package metadata now uses a setuptools-compatible PEP 621 license declaration,
and Python/R/CITATION links point to the public xhdfe-xfe distribution
repository. These metadata fixes do not change runtime behavior.

Versions: shared C++/Python/R package 2.18.2.20260715; Stata xhdfe
2.18.2; xhdfeakm remains 1.7.1; xhdfeconnected and xhdfegelbach
remain 1.2.1; xfe remains 1.10.1. Companion dates are refreshed to the
common release date without changing their behavior.

xhdfe 2.18.1.20260711

xhdfe 2.18.1.20260711 — clear AKM warnings and live progress

This patch release makes long xhdfeakm runs observable while they are still
running and replaces the generic “see r(notes)” warning with the complete
diagnostic at the point where the command returns.

User-facing changes

• xhdfeakm now prints the full inferential warning automatically. For
  example, match-level var(alpha) inference explains immediately that its
  SE/CI is unavailable under the canonical leave_out_COMPLETE oracle and
  that observation-level inference requires leaveoutlevel(obs).
• Non-convergence prints both the reliability warning and the available
  diagnostic details. r(notes) remains available for programs, but users no
  longer need to inspect it before another command overwrites r().
• With verbose, every progress line is flushed to the Stata Results window
  and the GUI is polled before the next numerical phase. Leave-out-set
  construction, FWL, solver setup, point effects, JLA draws, corrected
  components, SE simulations, eigen diagnostics and completion therefore
  appear live instead of arriving as an end-of-command dump.
• The same output-only flush applies to the shared verbose sink used by
  xhdfeconnected and xhdfegelbach.
• Without verbose, the compact default output is unchanged. No estimator,
  tolerance, stopping rule, result, API or backend-selection rule changed.

Validation

• Interactive Stata live test, 1,000,000 observations, 400 JLA draws and 200
  SE simulations per component: progress arrived while plugin call was
  still running, with approximately one-second updates and ETA. The run
  converged in 32.1 seconds and printed the full match-level var(alpha)
  warning automatically.
• Stata certification suite: 26/26 do-files passed.
• CPU and real-H100 CUDA AKM/KSS validators: all checks passed; maximum
  CPU/CUDA difference remained 1.11e-16.
• Real-H100 companion gate: CUDA was used; maximum CPU/GPU differences were
  1.60e-17 (Gelbach delta), 1.08e-19 (SE), and 4.24e-22
  (covariance).
• Mandatory 46.16-million-observation QP smoke: CPU 67.130s; real CUDA
  16.350s; both converged and returned identical coefficients and standard
  errors.
• Local Stata plugin: CUDA sm_90, OpenMP (libgomp) and -march=native.
• Default CPU and CUDA Python module directories rebuilt in Release mode;
  R package installation and Python/R version checks passed.

Versions: shared C++/Python/R package 2.18.1.20260711; Stata xhdfe
2.18.1; xhdfeakm 1.7.1; xhdfeconnected and xhdfegelbach 1.2.1;
xfe remains 1.10.1.