Metadata-Version: 2.4
Name: po-lang-engine
Version: 3.2.0
Summary: Po-Lang Engine — A high-performance, GPU-free programming language with native AI (BigLLM, FractalImage, BitEngine)
Home-page: https://github.com/po-lang/po-lang-engine
Author: Po-Lang
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Software Development :: Interpreters
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Requires-Dist: requests
Dynamic: author
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary


# Po-Lang Engine v3.2.0 — The Core Complete

Po-Lang is a **100% open, stateless, boundary-free** programming language with native AI.
This is the **Core Complete** manifesto release — no hidden memory, no restrictions.

## Core Complete Manifesto (v3.2.0)

### 1. Pure Dynamic Runtime (Python-style Freedom)
- Dynamic typing: variables change type anytime, anywhere
- Unrestricted control flow: nested loops, custom conditionals, dynamic functions
- Stateless execution: no background cache, no data locks — every step developer-controlled

### 2. No-Boundary File System
- **Any extension, any path:** `.po_pack`, `.brain`, `.weights`, `.dat`, or none
- **Multi-model generation:** loop in one script → hundreds of named model files
- Developer owns all state — engine writes exactly what developer commands

### 3. Infinite Context Window
- `llm["set_context"](n)` — from 8 tokens to unlimited (no upper cap)
- Modes: SHORT (<512), LONG-RANGE (≥512), INFINITE (≥1,000,000)
- 50% overlapping windows for maximum long-range dependency learning

### 4. Incremental Fine-Tune (1-bit XOR Adjustment)
- Base vocab intact — existing knowledge never erased
- New tokens appended, old patterns preserved
- Zero float math, zero GPU — pure bitwise XOR co-occurrence

## Full API

```po
use ai
use net

keep llm = ai.BigLLM()

# Infinite context — no upper limit
llm["set_context"](8192)

# Load enterprise base model (any filename/path)
llm["load"]("/var/models/global_base.weights")

# Fine-tune with new domain data
keep custom_data = ["Enterprise documentation 2026...", "New system rules..."]
llm["fine_tune"](custom_data, 5)

# Save to any custom path/name
llm["save"]("/var/models/my_custom_brain.weights")

# Generate & stream
keep reply = llm["generate"]("Po-Lang is", 128)
show reply

fn on_token(word, idx, done) { show word }
llm["stream"]("GPU-free AI", on_token, 64, 30)

# Fractal image synthesis
keep img = ai.FractalImage()
img["generate"]("sunset over mountains", 80, 24)
img["ascii"]()
img["save"]("output.ppm")
```

## Complete BigLLM API

| Method | Description |
|---|---|
| `llm["set_context"](n)` | Context window 8 → unlimited |
| `llm["train"](data, epochs)` | 1-bit streaming backprop, no GPU |
| `llm["fine_tune"](data, epochs)` | Incremental XOR adjustment, base intact |
| `llm["generate"](prompt, tokens)` | Text generation |
| `llm["stream"](prompt, fn, tokens, ms)` | Word-by-word streaming |
| `llm["save"]("any/path.ext")` | Binary save, any name/path/ext |
| `llm["load"]("any/path.ext")` | CRC32-verified load |
| `llm["info"]()` | Stats: vocab, ctx, params, version |

## Features
- Native AI/ML: Regression, Classification, KNN, Tokenizer, BigLLM, FractalImage
- Infinite context window (8 → unlimited tokens)
- Fine-tune: incremental 1-bit XOR, base model always preserved
- 1-bit XNOR+Popcount BitEngine (30× faster than Python float ops)
- Any filename/extension/path for save & load
- HTTP server with optional BPP binary encoding and SSC security
- REPL, bytecode compiler, and `pop` CLI
- Zero heavy dependencies — only standard Python

## Install
```bash
pip install --upgrade po-lang-engine
pop run myfile.po
pop repl
```
