Experimental bounded factorial model repair

NppAI factorial repair — experimental

Own dense v2 model, initialized from rc.2 4859ad69e93ff2ca80d8951bca617476d118f8ef127abc4b313b8d2f0671c6fd; 4096 updates, seed47,
batch8 (four original direct examples and four factorial examples), AdamW0.0003.
532 authored training records; per-example completion loss; fixed256-byte
prompt boundary. Optional width8 neural beam search uses generic AST/signature
and name-binding checks. An unambiguous requested function declaration may be
prefilled mechanically; all algorithm/body bytes come from model logits.
No test answers or algorithm templates are used by the decoder. For an explicit
requested declaration, the profile first accepts a complete, structurally valid,
value-returning greedy function in the legacy format. Otherwise it uses aligned
neural beam search. The route does not recognize particular operation names.

Model SHA-256: f8ef88dccbbd3280c21e5acd51c41c6744e6ba597aa63686f3f43fd96beac229.

Docker-tested result counts (raw outputs/cases/controls in report.json):

{
  "initial": {
    "wording-": {
      "total": 12,
      "passed": 0
    },
    "name-": {
      "total": 4,
      "passed": 0
    },
    "reproduction-": {
      "total": 2,
      "passed": 0
    },
    "plain-": {
      "total": 4,
      "passed": 0
    }
  },
  "initial_profile": {
    "wording-": {
      "total": 12,
      "passed": 0
    },
    "name-": {
      "total": 4,
      "passed": 0
    },
    "reproduction-": {
      "total": 2,
      "passed": 0
    },
    "plain-": {
      "total": 4,
      "passed": 0
    }
  },
  "repair_raw": {
    "wording-": {
      "total": 12,
      "passed": 12
    },
    "name-": {
      "total": 4,
      "passed": 1
    },
    "reproduction-": {
      "total": 2,
      "passed": 2
    },
    "plain-": {
      "total": 4,
      "passed": 4
    }
  },
  "repair": {
    "wording-": {
      "total": 12,
      "passed": 12
    },
    "name-": {
      "total": 4,
      "passed": 2
    },
    "reproduction-": {
      "total": 2,
      "passed": 2
    },
    "plain-": {
      "total": 4,
      "passed": 4
    }
  }
}

Original direct training probes: 88/96 before, 96/96 after in raw
legacy readout, 96/96 after in the actual production profile. No
original exact hit is lost in either readout. This measures memorization retention, not unseen accuracy.
Plain Polish requests are also training probes. The12 wording rows repeat one
authored description across two names, three parameters and two request modes. Wording and new-name rows are
authored/exposed development probes; one seed, one narrow operation family.
The generic search decoder can still produce syntactically valid wrong code.
Configured task tests remain mandatory before Apply. The aligned branch rejects tasks plus context longer than256 UTF-8 bytes,
without truncation; long repair feedback may therefore be rejected if the
legacy-format route cannot return a complete valid function. These results replace no
previous public0/12 benchmark result and do not establish general code quality.

Windows quick start

Download NppAI-factorial.nppai and NppAI-factorial-service.zip from this release.
Use the x64 plugin from v0.5.0-rc.2. Extract the service ZIP, open PowerShell there:

py -3.12 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements-inference.txt
.\.venv\Scripts\python.exe scripts/start_nppai.py --model C:\NppAI\NppAI-factorial.nppai --prompt-bytes 256 --python-functions --notepad 'C:\Notepad++\notepad++.exe'

Open an empty .py document and ask wygeneruj kod na silnię.
The launcher selects the own loopback service because the C++ runtime does not
implement this optional decoding profile. Legacy/default models stay greedy.
Use the included examples/silnia-validation-cases.json with a local Docker
Desktop Linux image; see docs/validated-generation.md. With no validator,
Apply remains disabled. The release GUI recording demonstrates the actual model
and review; it is not evidence of Docker Desktop or validated GUI Apply/Undo.
Those Windows end-to-end checks and upgrade remain unverified.

Source: af3e5325b06256f1d0cd448b939ed4d20e28edba

Exact main CI: https://github.com/deser1/NppAI/actions/runs/40414350060

Actual Windows request/review recorded; output equals Docker-tested Linux candidate. Windows Docker Desktop + validated GUI Apply/Undo and installation upgrade remain unverified.

NppAI v0.5.0-rc.2 — readable review and real generation demo

NppAI v0.5.0-rc.2

This experimental integration prerelease fixes the collapsed review diff found
while recording a real request in v0.5.0-rc.1. LF/CRLF/CR are normalized only in
the Win32 review display; actual model output and patch bytes are unchanged.

Downloads and startup

Download the plugin ZIP matching your Notepad++ architecture, NppAI-service.zip
and the separate NppAI-research-staged-mix.nppai. Close the editor before
replacing the NppAI plugin directory and keep a backup of the previous version.
Extract the service ZIP to a writable folder; no repository checkout is needed.
Compare SHA-256 values with SHA256SUMS.txt.

Open PowerShell in the extracted service folder:

py -3.12 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements-inference.txt
.\.venv\Scripts\python.exe scripts\start_nppai.py --model "C:\Models\NppAI-research-staged-mix.nppai" --notepad "C:\Program Files\Notepad++\notepad++.exe"

Keep the console open and follow docs/notepad-setup-pl.md for Docker Desktop
and authored tests. Apply is disabled until the required validation passes.

Actual demonstration and checks

notepad-live-demo.gif records the actual candidate DLL, official portable
Notepad++ 8.9.8.1 and own-model service from the extracted ZIP. It sends the
documented Polish factorial prompt, receives a real model HTTP 200, shows the
proposal/blocked review and scrolls to its actual code. No output is substituted.
The report retains the exact proposal and its AST syntax error; code is never
executed or applied in this demo. No Docker validator is configured in it.

The unchanged research model returns invalid code. Its retained functional
quality is still 0/12; this recording demonstrates integration, readable
failure and Apply protection, not successful factorial generation. The function
signature is supplied by the application. See MODEL_CARD.md for provenance.

Publication requires three architecture packages, native tests including actual
review-control line counts, real x64 editor generation, recording/report/asset
hash agreement and successful CI_build on the exact source commit.

Human upgrade behavior, Docker Desktop on the user's machine, validated GUI
Apply, and actual x86/ARM64 editor execution remain unverified. The earlier
release recording and raw failures
are retained separately from the corrected candidate demonstration.

Source commit: 5ddc609711c697262c7dd84ee0a4dad3afd43115

Verified main CI: https://github.com/deser1/NppAI/actions/runs/39322405472

NppAI v0.5.0-rc.1 — installation and validated review preview

NppAI v0.5.0-rc.1

This is an experimental prerelease of the editor integration and installation
flow. It is not a promotion of the model as a reliable coding assistant.

Included

• Windows x64, x86 and ARM64 plugin ZIPs, including the Python validation helper.
• A separate NppAI-service.zip with the own-model inference service, launcher,
  inference-only dependencies, Polish setup guide and factorial test cases.
  A repository checkout and PyTorch are not needed for inference.
• A separately downloadable NppAI-research-staged-mix.nppai, its model card
  and SHA-256. This is the unchanged research checkpoint used by installation CI.
• Automatic local/server routing, bounded repair attempts, Docker-backed Python
  validation, visible proposal/diff, guarded Apply/Reject and Unicode fixes.

Start

1. Close Notepad++. Extract the matching plugin ZIP and place its NppAI folder
   in the editor's plugins directory. Back up an existing plugin first.
2. Extract NppAI-service.zip to a writable folder. Download the research model
   separately and compare its SHA-256 with MODEL_CARD.md or SHA256SUMS.txt.
3. Open PowerShell in the extracted service folder:

py -3.12 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements-inference.txt
.\.venv\Scripts\python.exe scripts\start_nppai.py --model "C:\Models\NppAI-research-staged-mix.nppai" --notepad "C:\Program Files\Notepad++\notepad++.exe"

Keep the console open. Follow docs/notepad-setup-pl.md for Docker Desktop and
authored validation cases. Without validation, Apply remains disabled.

Evidence and limitations

The publication gate builds all three architectures, checks actual ZIP contents,
and launches x64 in official portable Notepad++ 8.9.8.1. The own-model service
runs from the extracted service ZIP rather than a repository checkout. The smoke
checks readiness, real menu/panel controls and a Polish prompt round trip.
The release also waits for successful CI_build on the exact source commit.

The supplied model achieved 0/12 functional passes on six bilingual tasks
in the retained staged-protocol evaluation. Experimental continuations also
remain 0/12. Training fit is not evidence of useful new-task generation.
See the model card and linked reports; inspect every proposal and test result.

Not certified here: upgrade behavior, the user's Docker Desktop setup, GUI
Apply after successful validation, or actual x86/ARM64 editor execution. There
is no recording claiming that the model successfully generates a working program.

The release contains SHA-256 checksums and the machine-readable installation
report. The test is a reproducible integration demonstration, not a human demo
or proof of autonomous programming.

Source commit: c4e307f3ee1b07e258f9ced0b0f404ae4def3c47

Verified main CI: https://github.com/deser1/NppAI/actions/runs/39312015496

NppAI v0.4.0

NppAI v0.4.0

NppAI v0.4.0 focuses on making the project easier to install, evaluate, and use while expanding AI generation with repository-aware context.

🚀 What's New

Repository-Aware AI Context

NppAI can now use relevant repository files as additional context during AI-assisted code generation.

This provides a foundation for more project-aware suggestions by allowing generation to consider information from the surrounding codebase instead of relying only on the currently edited file.

📦 Ready-to-Install Plugin Packages

NppAI releases now provide prebuilt Notepad++ plugin packages for:

• Windows x64 — NppAI-x64.zip
• Windows x86 — NppAI-x86.zip
• Windows ARM64 — NppAI-arm64.zip

Each package contains the plugin DLL in a Notepad++-compatible directory structure together with project and model-format documentation.

⚙️ Automated Release Pipeline

Version tags now trigger an automated GitHub Actions release pipeline.

The workflow:

1. Builds NppAI in Release configuration.
2. Builds x64, x86, and ARM64 versions.
3. Creates installation-ready ZIP packages.
4. Uploads build artifacts.
5. Attaches the packages to the corresponding GitHub Release.

This ensures downloadable binaries correspond directly to the tagged source revision.

📥 Installation

Download the ZIP matching your Notepad++ architecture.

Extract the included NppAI directory into your Notepad++ plugins directory.

For a typical x64 installation:

C:\Program Files\Notepad++\plugins\NppAI\NppAI.dll

Restart Notepad++ and verify that NppAI appears in the Plugins menu.

🧠 Models

NppAI uses its own .nppai model format.

Model files are intentionally not bundled with plugin releases.

Provide a compatible .nppai model separately according to the model-format documentation included with the package.

🛡️ Quality & CI

The release continues to use the project's automated validation pipeline, including:

• Windows x64, x86, and ARM64 builds
• Debug and Release configurations
• Native backend tests
• Generation pipeline tests
• Tensor and tokenizer tests
• Benchmark regression checks
• Model-format and integrity validation

📌 Release Assets

Download the package matching your system:

• NppAI-x64.zip
• NppAI-x86.zip
• NppAI-arm64.zip

🔭 Next Steps

Future development will continue improving:

• Repository-aware generation
• RAG quality and context selection
• Inference performance
• Model tooling
• API hardening
• Automated testing
• Developer experience
• Notepad++ integration

---

NppAI is an independent AI coding assistant for Notepad++ featuring a custom C++ inference engine, its own .nppai model format, repository-aware context, and tools for training coding models on private codebases.

NppAI v0.3.0

NppAI v0.3.0

NppAI v0.3.0 focuses on model integrity, CPU compatibility, tokenizer reliability, end-to-end testing, and CI performance regression detection.

Added

• Versioned .nppai model format v2.
• Explicit model magic value and format version.
• SHA-256 payload integrity verification.
• Explicit model payload length metadata.
• End-to-end generation tests covering:
  • v2 model loading
  • SHA-256 validation
  • BPE tokenization
  • inference
  • generated output
• Scalar vs SIMD parity tests for:
  • FP32 matrix multiplication
  • INT8 matrix multiplication
  • RMSNorm
• Extended tokenizer tests covering:
  • UTF-8 round trips
  • source-code whitespace
  • long inputs
  • chained BPE merges
• CI tensor benchmark regression gate.
• Per-size FP32 and INT8 performance limits.
• Benchmark regression diagnostics.

Changed

• Added runtime AVX2/FMA capability detection on supported x64 Windows systems.
• Added automatic scalar fallback when AVX2/FMA is unavailable.
• Removed the global x64 AVX2 compiler requirement.
• Strengthened model loading with exact tensor payload-size validation.
• Truncated model payloads are rejected.
• Model files containing unexpected trailing data are rejected.
• New training exports use .nppai model format v2.
• Legacy v1 model files remain supported.
• Benchmark artifacts are preserved when the CI performance gate fails.

Security & Integrity

• SHA-256 verification is performed before model state is committed.
• Exact payload-length validation happens before tensor allocation.
• Corrupted v2 model payloads are rejected.
• Unsupported model-format versions are rejected.

SHA-256 provides integrity and corruption detection. It does not provide model authenticity or cryptographic signing.

Performance

NppAI now performs runtime AVX2/FMA detection instead of requiring AVX2 globally.

Supported CPUs can use optimized SIMD kernels, while systems without the required instruction set automatically use the scalar implementation.

CI also monitors FP32 and INT8 tensor performance to detect major performance regressions.

Compatibility

• Windows x64
• Runtime AVX2/FMA detection
• Scalar CPU fallback
• Legacy .nppai v1 model support
• .nppai v2 with SHA-256 integrity verification

Known Limitations

• Legacy v1 models do not contain SHA-256 integrity metadata.
• SHA-256 does not authenticate the origin of a model.
• Non-MSVC x86/x64 builds currently use the scalar path instead of runtime AVX2/FMA dispatch.
• CI benchmark limits are intentionally conservative to account for GitHub-hosted runner variance.

Release

Version: v0.3.0

Release commit:

cdbec50466e149e3589adb3708dd2eb4862a4c79

This release includes the development work completed after NppAI v0.2.0 through the v0.3.0 release preparation.

NppAI v0.2.0

NppAI v0.2.0

NppAI v0.2.0 focuses on reliability, testing, documentation, backend hardening, and optimized INT8 inference.

Added

• Native CTest coverage for:
  • tensor math
  • model loading
  • tokenizer fallback
  • generation pipeline
• Generation-pipeline fixture verifying BPE merging through public generation behavior.
• Backend automated tests.
• CI benchmark coverage.
• Contributor documentation.
• Architecture documentation.
• Model-format documentation.
• Testing documentation.
• Security documentation.

Changed

• Improved INT8 inference performance on x64 systems with AVX2/FMA.
• Strengthened model-header validation.
• Added minimum model-payload validation.
• Improved backend request-size handling.
• Moved expensive hashing work away from the backend event loop.
• Added model-version-aware caching.
• Improved CI and automated test coverage.

Testing

NppAI v0.2.0 introduces significantly broader automated testing for the native C++ inference engine.

CTest now validates core areas including tensor operations, model loading, tokenizer fallback behavior, and the complete generation pipeline.

The generation test also verifies BPE merging through the public generation API rather than testing only isolated internal functions.

Performance

INT8 inference received optimized x64 AVX2/FMA execution paths.

Benchmark coverage was added to CI to make performance behavior easier to track during future development.

Security & Reliability

• Model headers receive additional validation before loading.
• Minimum expected tensor payload size is validated.
• Backend request sizes are constrained.
• Expensive hashing operations are moved away from the event loop.
• Model cache entries account for model versions.

Documentation

New project documentation covers:

• architecture
• contributing
• model format
• testing
• security

These documents make the repository easier to understand, test, maintain, and contribute to.

Known Limitations

• v0.2.0 requires AVX2/FMA for optimized x64 execution.
• Runtime SIMD dispatch and scalar fallback are not yet available.
• Model loading validates the minimum required payload but does not yet reject all trailing data.
• The legacy model format does not contain SHA-256 payload integrity metadata.

These limitations are addressed or improved in NppAI v0.3.0.

Release

Version: v0.2.0

Release commit:

9d9ca1a758f87428bdd36826da497199d714ee21