{"slug": "taco-cross-platform-llm-based-compressor-eliminates-floating-point", "title": "Taco: Cross platform LLM based compressor, eliminates floating point", "summary": "Taco 0.1.0, an alpha proof-of-concept lossless compressor released on 2026-10-19, folds and unfolds a 3,672-byte English text sample to 648 bytes with an identical SHA-256 hash (2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e) across 7 backends spanning 3 operating systems, 2 CPU architectures and 4 processor types. Taco's HardShell engine runs a GPT-2 language model in integer arithmetic only, so every CPU and GPU produces bit-identical predictions and a file folded on one machine unfolds on all the others. The author states most of the code, tests and documentation were written by Anthropic's Claude under his direction, and warns Taco is slow and not a replacement for zstd or xz.", "body_md": "*Hard shell. No floats. Same taco on every machine.*\n\nTaco is a lossless compressor that uses a language model (GPT-2). The model predicts the next\npiece of the data, and a range coder stores only what the model did not predict. The engine of\nTaco, **HardShell**, runs the model with **integer arithmetic only**. Thus every CPU and GPU\ncalculates the same predictions, bit for bit. A file that one machine compresses (\"folds\")\ndecompresses (\"unfolds\") on every other machine.\n\n```\ntaco fold notes.txt          # makes notes.txt.taco\ntaco unfold notes.txt.taco   # restores notes.txt, byte for byte\n```\n\nWarning\n\n**Alpha: a proof of concept (version 0.1.0, 2026-10-19).** Taco is an experiment. It is\nslow, and it is not a replacement for zstd or xz. Keep a second copy of data that you fold. Read\n[Limits](#limits) before you use it.\n\nNote\n\n**How this code was written.** Most of the code, the tests and the documents in this\nrepository were written by Claude (an AI model by Anthropic) with Claude Code, under the\ndirection of the author, to get to results faster. The author made the design decisions.\nTrust the code only as far as the tests show: conformance vectors, the cross-machine check,\nfuzzing and the comparison of every fast path with the reference path.\n\nThis is the point of Taco. Speed and ratio come second.\n\nThe release program of version 0.1.0 folded the demo sample (`demo/samples/sample.txt`, 3,672\nbytes, `--profile text`) and unfolded it again on 7 backends: 3 operating systems, 2 CPU\narchitectures and 4 kinds of processors. Each fold ran on the backend in the row, and each\nunfold restored the sample byte for byte (measured, 2026-10-19):\n\n| Machine | System | Backend | SHA-256 of the `.taco` file | \n|---|---|---|---|\n| Apple M2 | macOS (ARM) | CPU (NEON) | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| Apple M2 | macOS (ARM) | GPU (Metal) | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| AMD Ryzen 7 5800H | Linux x86-64 | CPU (AVX2) | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| NVIDIA RTX 3060 Laptop | Linux x86-64 | CUDA | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| AMD Ryzen 7 5800H | Windows x86-64 | CPU (AVX2) | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| NVIDIA RTX 3060 Laptop | Windows x86-64 | CUDA | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n| NVIDIA RTX 3060 Laptop | Windows x86-64 | GPU (Vulkan) | `2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e` | \n\nThus a file that any of these machines folds unfolds on all of the others. To add a row, run\n`./try` on your machine ([Try it](#try-it)) and compare the hash. More checks of the same\nproperty, with more inputs, are in [Same bits on different machines](#same-bits-on-different-machines).\n\nThere are two ways. Both give the same `.taco` bytes.\n\n1. Open the [Releases page](https://github.com/tac0mania/taco/releases) and download`taco-demo-0.1.0.zip` (about 120 MB). It has the programs for macOS (Apple Silicon), Linux\n(x86-64) and Windows (x86-64), the model file`gpt2.hsm` , and a one-command demo. If you want\nonly the program for one system, download`taco-0.1.0-<system>.tar.gz` (or`.zip` for\nWindows); it does not include the model file.\n2. Unpack the zip and open a terminal in the unpacked folder (`taco-demo-0.1.0` ).\n3. Run `./try` (macOS, Linux) or`try.cmd` (Windows).\n\nThe demo folds and unfolds a short English text (3,672 bytes), checks it, and prints the SHA-256\nof the `.taco` file. It takes about 10 s to 1 minute. The end of the output:\n\n```\nPASS: the file came back byte for byte.\nOriginal: 3672 bytes. Folded: 648 bytes.\nSHA-256 of the .taco file: 2fab1ef7a1c70cd4e39ddfd88a8d66389ae07a403111db131326ae425460652e\n```\n\n**This hash is the same on every machine and every backend.** Run the demo on a second\ncomputer and compare. To fold your own files, use `./taco fold notes.txt` and\n`./taco unfold notes.txt.taco` in the same folder (Windows: `taco.cmd`). Details and\ntroubleshooting: [`demo/README.md`](https://github.com/tac0mania/taco/blob/main/demo/README.md).\n\n**You need:** [rustup](https://rustup.rs) (it installs Rust 1.99.0 from\n`rust-toolchain.toml`), [uv](https://docs.astral.sh/uv/) for the Python tools, a C compiler (for\nzstd), about 1.5 GB of disk and 8 GB of memory. A GPU is optional.\n\n```\ngit clone https://github.com/tac0mania/taco.git && cd taco\nuv run --project tools python -m baseline.fetch     # GPT-2 weights; the tool checks each SHA-256\nuv run --project tools python -m convert.gpt2       # makes tools/data/out/gpt2.hsm (about 1 minute)\nshasum -a 256 tools/data/out/gpt2.hsm               # must be aaa03eb96e9ad795...b51001ba5c2\ncargo build --release --locked -p taco-cli\nexport TACO_MODEL=\"$PWD/tools/data/out/gpt2.hsm\"\n./target/release/taco fold demo/samples/sample.txt --profile text -o /tmp/sample.taco\nshasum -a 256 /tmp/sample.taco                      # must be the hash in section A\n./target/release/taco unfold /tmp/sample.taco -o /tmp/sample.txt\ncmp demo/samples/sample.txt /tmp/sample.txt && echo \"restored byte for byte\"\n```\n\n- The converter calculates with exact fractions, so your `gpt2.hsm` is the same file, byte for\nbyte, as the one in the release. If its hash is different, do not use it.\n- Your `.taco` file must have the hash of section A. Then your build and the release program\nare compatible: each one unfolds the files of the other.\n- `scripts/release/build.sh <target>` makes the release archive itself. It builds with fixed\npaths and times, so two builds of one commit on one machine gave the same binary, byte for\nbyte (measured on Linux).`BUILDINFO` in each archive records the commit and the SHA-256 of\nthe program.\n\nCaution\n\nTaco is slow. With a GPU, it folds text at about 85 to 129 KB/s and unfolds at about 26 to 31 KB/s. With the CPU only, it folds at about 0.3 to 2 KB/s and unfolds at about 0.1 to 0.5 KB/s (measured). Start with a file of a few KB.\n\n**Taco is** a compressor whose output does not depend on the machine. Its parts are:\n\n- an open specification of integer-only GPT-2 inference (`docs/adr/0004-hardshell-numerics.md` );\n- an exact converter: it reads each float32 weight as `mantissa x 2^exponent` and calculates\nwith exact fractions, so every machine makes the same model file (ADR 0014);\n- implementations for the CPU (NEON, AVX2), NVIDIA GPUs (CUDA) and other GPUs (wgpu: Vulkan, Metal, DX12), which tests show give the same bits;\n- conformance vectors that connect the model to the bytes of real `.taco` files.\n\n**Taco is not** the first or the best compressor with a language model:\n\n- [ts_zip](https://bellard.org/ts_zip/) (Fabrice Bellard) makes smaller files and is faster.\nIts page also states that its result does not depend on the GPU or the CPU.\n- The ideas under Taco have earlier work: language models with entropy coders\n([LLMZip](https://arxiv.org/abs/2306.04050) ), integer networks for compression that decode\nthe same on every platform\n([Ballé et al., 2019](https://research.google/pubs/integer-networks-for-data-compression-with-latent-variable-models/) ),\nand integer-only Transformers ([I-BERT](https://proceedings.mlr.press/v139/kim21d.html) ).\n\nWhat Taco adds is the combination: an inspectable integer specification, a repeatable model conversion, several independent implementations, and tests that show they agree.\n\nAll numbers are measured unless they are labelled \"published\" or \"est.\". Details are in\n`docs/research/`. The sizes do not include the model file (127 MB), which both machines must\nhave.\n\n| File | Original | **Taco** | xz -9e | zstd -19 | \n|---|---|---|---|---|\n| English book (32 KiB) | 32,768 | **8,432** | 12,400 | 12,463 | \n| HTML page | 24,603 | **4,759** | 7,652 | 7,713 | \n| English (4 KiB) | 4,096 | **1,237** | 1,684 | 1,599 | \n| Server log (16 KiB) | 16,384 | **3,129** | 3,164 | 3,139 | \n| Excel file (binary) | 8,192 | 8,285 (stored raw) | **1,672** | 2,097 | \n\nAgainst another compressor with a language model, on the whole `alice29.txt` (152,089 bytes):\n\n| Compressor | Bytes | Bits per byte | \n|---|---|---|\n| xz -9e | 48,492 (published) | 2.55 | \n| **Taco** | **38,939** | **2.05** | \n| ts_zip | **21,713** (published) | **1.14** | \n\nts_zip is 44% smaller. It uses a larger and newer model (RWKV, 169M parameters; GPT-2 small\nhas 124M), and Taco's profile `text` restarts the model context at each 16 KiB block.\n\nThe 16 Loghub log files (4,458,875 bytes in total), the defaults of the profile `logs` (blocks\nof 64 KiB, context overlap 512), whole files for the other compressors\n(`docs/research/2026-10-19-overlap-cli.md`, `docs/research/2026-10-19-logs-profile.md`):\n\n| Compressor | Bits per byte | \n|---|---|\n| zstd -19 --long=27 | 0.597 | \n| xz -9e | 0.554 | \n| **Taco, profile `logs`** | **0.494** (10.8% smaller than xz) | \n| paq8px -8 (a slow context-mixing compressor) | smaller than Taco: 0.348 against 0.600 (est.) on 6 other whole logs | \n\nSpeed of the profile `logs` with the GPU mixer (RTX 3060 at 95 W, CUDA, commit 1493af3):\n\n| File | Fold | Unfold | \n|---|---|---|\n| `Apache_2k.log` , 171 KB | 4.5 s (was 208.8 s on the CPU) | 53.8 s (was 90.1 s) | \n| `apache_access.log` , 2.37 MB | 70 to 98 s | 255 to 280 s | \n\nWhat can make logs smaller (not in this version): the skip rule, 4.8 to 7.3% smaller (est.,\nsimulation, ADR 0017); and a model fine-tuned on the logs of known systems, 53.2% smaller on\nthose systems but 4.6% larger on other systems (measured, frozen;\n[Experiments](#experiments-that-do-not-ship)).\n\n| Model | Bits per byte (16 text files, 42,256 bytes) | \n|---|---|\n| GPT-2 small, float | 1.867 | \n| GPT-2 small, integer ( `gpt2.hsm` ) | 1.871 (+0.2%) | \n\nThe +0.2% is a total. Single files change from −9.0% to +6.6%. The conversion saturates large\nactivations, which changes the predictions; against a float model with the same saturation,\nthe integer model is 2.3% larger (`docs/research/2026-10-18-integer-gpt2.md` §6).\n\n| What | Speed | \n|---|---|\n| Engine, decode over a full 1,024-token window | 20,472 tokens/s | \n| `taco fold` , English text | 85 to 129 KB/s | \n| `taco unfold` , English text | 26 to 31 KB/s | \n| `taco fold` , CPU only | about 0.3 to 2 KB/s | \n| `taco unfold` , CPU only | about 0.1 to 0.5 KB/s | \n\nFor comparison, `zstd -3` compresses at hundreds of MB/s and `xz -9e` at about 0.7 MB/s.\nts_zip states \"up to 1 MB/s\" on an RTX 4090 (published, a different GPU).\n\nThis test checks that the memory does not grow with the file (ADR 0018). It used 200,000,000 bytes of random words and the small test model, on the devbox CPU.\n\n| Run | Largest memory (RSS) | \n|---|---|\n| fold, file to file | 254 MiB | \n| fold, stdin to stdout | 276 MiB | \n| unfold, file to file | 38 MiB | \n| unfold, stdin to stdout | 35 MiB | \n\nBoth unfolds restored the input byte for byte. **Its times say nothing about Taco's speed:**\nthe test model has random weights, so every block was stored with zstd or raw, and unfold ran\nno model step. The real speed is in the table above. The largest files folded with GPT-2 so\nfar are 2.4 to 2.7 MB (measured).\n\n| Check | Result | \n|---|---|\n| Mac (ARM) folds, Linux (x86) unfolds, and the reverse ( `scripts/xcheck` , 12 inputs) | 12 of 12 restored each way; 12 of 12 `.taco` files identical | \n| Native Windows x86 against the Mac ( `scripts/wcheck` ) | 9 of 9 `.taco` files identical, 9 of 9 restored | \n| CPU, CUDA and wgpu (Metal, GL) | the same bytes, 14 of 14 GPU cases | \n| CI on each push: Linux x86-64 and Linux ARM64 | the same 50 conformance hashes | \n| Fuzzing: damaged containers, coder streams and model files | millions of cases, 0 failures ( `docs/security.md` ) | \n\n- \n**No floating-point arithmetic in fold or unfold.** The engine, the coder, the mixer and the\nGPU kernels use integers only.`scripts/check-no-floats.sh` checks this on each push.\n- \n**The same result on every machine, when each operation is fully specified.** Integers alone\nare not sufficient. Taco makes these conditions rules (`CLAUDE.md` §1):\n  - every sum has an accumulator that is wide enough, with the bound written in the code, or it wraps on overflow in a defined way;\n  - every rounding and every clamp has one written rule (ADR 0004);\n  - signed division uses floor-division helpers.\n Then a compiler, a CPU type or a GPU driver has no freedom to change a result. Tests check these conditions. Tests cannot prove that the code obeys them everywhere.\n- \n**The model file is the same on every machine.** The Mac and Linux make the same`gpt2.hsm` ,\nbyte for byte. Its SHA-256 is`aaa03eb96e9ad7957432168c8ac6b4a99ed55d57e637e4786a664b51001ba5c2` .\n- \n**A wrong result is never silent.** Each`.taco` file stores the SHA-256 of the original\ndata, and`taco unfold` checks it.\n\nImportant\n\n**The checksum finds an error. It cannot repair one.** If `taco unfold` fails, try again with\n`--backend cpu` or on a different machine. If the error happened during `taco fold` (a bug\nor a hardware fault on that machine), no decoder can restore the file. Keep the original\nuntil you have unfolded the `.taco` file one time.\n\nThese problems can still occur, as in every program: a bug in our code, a bug in a GPU driver (Taco runs a self-test before it uses a GPU, and uses the next backend if the test fails), or a hardware fault. In each case the SHA-256 check finds the error.\n\n| Hardware | Backend | Result | \n|---|---|---|\n| Apple M2 (macOS) | CPU (NEON), GPU (wgpu on Metal) | bit-exact | \n| AMD Ryzen 7 5800H (Linux, native Windows) | CPU (AVX2) | bit-exact | \n| NVIDIA RTX 3060 Laptop | CUDA | bit-exact | \n| NVIDIA RTX 3060 Laptop | wgpu on OpenGL (Linux), DX12 with DXC (Windows) | bit-exact | \n| AMD Radeon iGPU (Ryzen 7 5800H), native Windows | wgpu on DX12 with DXC | bit-exact | \n| NVIDIA RTX 3060, AMD Radeon iGPU, native Windows | wgpu on Vulkan | bit-exact (4 op tests; the full model tests did not run yet) | \n| GitHub Actions: Linux x86-64, Linux ARM64 | CPU | the same 50 conformance hashes | \n\n**Not tested yet:** Intel GPUs; AMD GPUs on Linux; AMD discrete GPUs; macOS on Intel;\nbig-endian and 32-bit CPUs; phones and browsers.\n\n**GPU notes:**\n\n- AMD and Intel GPUs need no special code. They use wgpu and the normal GPU driver.\n- The CUDA backend needs compute capability 8.0 or more (RTX 30 series, A100 and later). Older NVIDIA GPUs use wgpu or the CPU. The bits are the same; only the speed changes.\n- On Windows, DX12 with the old FXC shader compiler cannot compile 7 of the 14 kernels. The self-test then fails, and Taco uses the next backend. Vulkan, Metal and DX12 with DXC work.\n\n| Limit | Details | \n|---|---|\n| **Slow** | See [Speed](#speed-rtx-3060-laptop-gpu-95-w) . A GPU is strongly recommended. | \n| **Small files unfold slowly** | One block decodes one token after the other: about 10 to 13 s for a 16 KiB block on the RTX 3060 (est. from measured times). | \n| **English only** | GPT-2 is an English model. On German and French, Taco is larger than PPMd; on Chinese, larger than gzip (measured). | \n| **Binary data** | Photos, video, archives and other binary files are stored with zstd or raw. Use zstd for them. | \n| **Logs** | The profile `logs` is smaller than xz, but paq8px is smaller still (measured). | \n| **The model file** | 127 MB. Both machines must have the same file. The release does not download it yet. | \n| **Untrusted model files** | A model file can state a very large KV cache (finding F6, open). Load only the published `gpt2.hsm` . | \n| **Wide models** | Model-file version 2 runs on the CPU and with CUDA, not on wgpu yet. The default `gpt2.hsm` is version 1 and runs everywhere. | \n| **Format** | Container version 2 is frozen: later versions of Taco read the files of this version. | \n| **Release 0.1.0-alpha.1** | Its programs fold the default profile `auto` on the CPU (use`--profile text` for the GPU), and a crafted`.taco` file can use about 11 GB in GPU unfold (F2; use`--backend cpu` for untrusted files). Both are fixed on`main` ; the GPU logs speeds above are from`main` . | \n\nA symbol that the model expects with probability *p* costs about −log₂(*p*) bits. For each\nposition, the model gives a probability to each of the 50,257 GPT-2 tokens. The range coder\ndivides a number range in proportion to these probabilities. The decoder runs the same model,\ndivides the range in the same way, and finds the token.\n\nThe decoder must calculate **exactly** the same probabilities as the encoder. If one frequency\nis different by one unit, the decoder can select a wrong token, and all output after it is\nwrong. Floating-point results can change with the order of additions, the chip, the math\nlibrary and the batch size. Specified integer results do not change. Thus HardShell uses `i8`\nweights, `i32` and `i64` sums, one rounding rule, and tables for GELU and `exp` that are stored\nin the model file.\n\n``` php\nflowchart LR\n  A[input bytes] --> B[blocks]\n  B --> C[tokenizer<br/>byte-level BPE]\n  C --> D[HardShell<br/>integer GPT-2]\n  D --> E[frequency table]\n  E --> F[range coder]\n  F --> G[.taco file<br/>model hash + SHA-256]\n  G -. unfold: same model,<br/>same table .-> H[original bytes<br/>checksum verified]\n```\n\n- **Blocks** are independent, so they run in parallel, and damage stays in one block.\n- A block that does not become smaller is stored **zstd or raw** . The worst-case growth is the\n104-byte header and 5 bytes for each block.\n- The profile **`logs`** adds a match model and a mixer for repeated lines. The profile**`auto`** (the default) selects the smaller result for each block.\n- The file format is in ADR 0006 and ADR 0011. The model file format is in ADR 0004.\n\n**The full explanation** of every part, with the measurements and the reasons for each\ndecision, is in [`docs/core-architecture.md`](https://github.com/tac0mania/taco/blob/main/docs/core-architecture.md). If you are new to\ncompression or machine learning, start with [`docs/primer.md`](https://github.com/tac0mania/taco/blob/main/docs/primer.md): it explains\nIEEE 754 floating point, entropy, range coding, transformers and quantisation from the start.\n\nSee [Try it, B](#b-build-the-same-program-yourself).\n\n```\ntaco fold   <input>      [-o <output>] [-c] [--profile text|logs|auto] [--backend auto|cuda|gpu|cpu]\ntaco unfold <input.taco> [-o <output>] [-c] [--backend auto|cuda|gpu|cpu]\n```\n\n| Option | Meaning | \n|---|---|\n| `-o <path>` ,`-c` | The output file, or stdout. The input `-` is stdin. | \n| `-m <path.hsm>` | The model file. Default: the `TACO_MODEL` environment variable. | \n| `--profile` | Fold only. `text` (GPT-2),`logs` (GPT-2, match model, mixer) or`auto` (default). | \n| `--backend` | `cuda` ,`gpu` (wgpu),`cpu` or`auto` (default: the first that passes a self-test). The output is the same on every backend. | \n| `--block-size` ,`--overlap` | Fold only. Block size (default 16 KiB for `text` , 64 KiB for`logs` and`auto` ) and context overlap. | \n| `--threads <n>` | Worker threads. The output does not change. | \n| `-f` ,`-q` ,`-V` | Replace an output file; no progress output; show the version. | \n\nFiles of any size stream with bounded memory ([Large files](#large-files-streaming-a-memory-test-not-a-speed-test)). `taco --help` and `docs/man/taco.1` have all the details.\n\nThe alpha shows one property: the same bits on every machine. These items come later. None of them changes that property, and files from the alpha stay readable.\n\n| Item | Expected gain | \n|---|---|\n| Speculative decoding in `taco unfold` (ADR 0017) | Unfold 1.8 to 3.7 times faster (est., simulation) | \n| Skip rule (mixer rule 2) for the profile `logs` | Logs 4.8 to 7.3% smaller (est., simulation on 18 log files) | \n| Smaller blocks for small text files | Unfold of a 25 KB file from 13.7 s to 4.7 s, for 2.3% more bytes; a 427 KB file from 17.7 s to 10.7 s, for 1.0% more (measured) | \n| More context for the profile `text` | Smaller files (not measured) | \n| Range coder on the GPU | Removes one CPU-GPU round trip for each token (not measured) | \n| CUDA for compute capability 6.1 and 7.5 | Faster on older NVIDIA GPUs (not measured) | \n| Model download in `taco` (`docs/design/model-distribution.md` ) | No manual model setup | \n| Other models with an automatic converter ( `docs/design/anymodel.md` ) | Designed | \n\n**A model fine-tuned on logs (\"Route A\", frozen).** distilgpt2 (6 layers) fine-tuned on 12\nLoghub systems, against GPT-2 and the general compressors. `taco fold --profile logs`, the\nfirst 16 KiB of each file, sizes in bytes (measured, `docs/research/2026-10-19-route-a.md` §8):\n\n| Sample (16,384 bytes each) | xz -9e | zstd -19 | Taco, GPT-2 | Taco, fine-tuned | \n|---|---|---|---|---|\n| 4 log systems **seen** in training (Android, HDFS, Mac, OpenStack) | 10,872 | 10,897 | 7,672 | **3,593** | \n| 4 log systems **not seen** in training (Apache, HealthApp, Proxifier, Zookeeper) | 4,664 | 4,578 | **3,709** | 3,879 | \n\n- On seen systems, the fine-tuned model is 67% smaller than xz and 53% smaller than GPT-2.\n- On unseen systems, it is 4.6% larger than GPT-2 (but still 17% smaller than xz).\n- Its engine is 1.5 times faster than GPT-2 (30,319 against 20,472 tokens/s), because it has 6 layers instead of 12.\n- Thus a model fine-tuned on the logs of one company would be the strong case. It is frozen,\nbecause the alpha is about the same bits on every machine, not about ratio. Details:\n[`docs/core-architecture.md`](https://github.com/tac0mania/taco/blob/main/docs/core-architecture.md) §8.6.\n- ts_zip publishes no log results, so this table has no ts_zip column.\n\n---|---|---|\n| A model fine-tuned on logs (distilgpt2, 6 layers, trained on 12 Loghub systems; \"Route A\") | On logs of the 12 trained systems: 53.2% smaller than GPT-2 (profile `logs`). On 4 unseen systems: 4.6% larger. Engine 1.5 times faster (30,319 against 20,472 tokens/s, smaller model) | Frozen: the alpha is about cross-machine bits, not ratio. Details: [`docs/core-architecture.md`](https://github.com/tac0mania/taco/blob/main/docs/core-architecture.md) §8.6 |\n\nRead [`CLAUDE.md`](https://github.com/tac0mania/taco/blob/main/CLAUDE.md) before you change code. It has the rules that keep Taco\nbit-exact. The most important rule: **no floating-point arithmetic in the prediction path.**\n\n| Document | Contents | \n|---|---|\n| [`docs/core-architecture.md`](https://github.com/tac0mania/taco/blob/main/docs/core-architecture.md) | How Taco works, end to end, with the measurements | \n| [`docs/primer.md`](https://github.com/tac0mania/taco/blob/main/docs/primer.md) | The background: floating point, compression, language models | \n| [`HANDOFF.md`](https://github.com/tac0mania/taco/blob/main/HANDOFF.md) | The current state and the next steps | \n| [`docs/ARCHITECTURE.md`](https://github.com/tac0mania/taco/blob/main/docs/ARCHITECTURE.md) | The code map: crates, tools and permitted dependencies | \n| [`docs/design/plan.md`](https://github.com/tac0mania/taco/blob/main/docs/design/plan.md) | The design | \n| [`docs/adr/`](https://github.com/tac0mania/taco/blob/main/docs/adr) | The decisions | \n| [`docs/research/`](https://github.com/tac0mania/taco/blob/main/docs/research) | The measurements | \n| [`docs/security.md`](https://github.com/tac0mania/taco/blob/main/docs/security.md) | The threat model and the fuzzing results | \n| [`docs/ci.md`](https://github.com/tac0mania/taco/blob/main/docs/ci.md) | CI and the cross-machine conformance check | \n\n```\nscripts/check.sh   # tags, no floats, fmt, clippy -D warnings, all tests\nscripts/xcheck     # the cross-machine check: Mac (ARM) and devbox (x86), 12 inputs\n```\n\nA change to the coder, the model file, the tables or the container changes the bytes of\n`.taco` files. It needs a new format version, a reader for the old version, new conformance\nvectors and an ADR (`CLAUDE.md` §1 and §8).\n\nApache-2.0. See [`LICENSE`](https://github.com/tac0mania/taco/blob/main/LICENSE).\n\nThe GPT-2 weights are from OpenAI (modified MIT licence) and are not in this repository.\n`tools/baseline` downloads them.", "url": "https://wpnews.pro/news/taco-cross-platform-llm-based-compressor-eliminates-floating-point", "canonical_source": "https://github.com/tac0mania/taco", "published_at": "2026-10-19 20:27:20+00:00", "updated_at": "2026-10-19 20:46:48.041971+00:00", "lang": "en", "topics": ["artificial-intelligence", "large-language-models", "ai-tools", "developer-tools"], "entities": ["Taco", "HardShell", "GPT-2", "Anthropic", "Claude", "Claude Code", "Apple M2", "NVIDIA RTX 3060 Laptop"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/taco-cross-platform-llm-based-compressor-eliminates-floating-point", "markdown": "https://wpnews.pro/news/taco-cross-platform-llm-based-compressor-eliminates-floating-point.md", "text": "https://wpnews.pro/news/taco-cross-platform-llm-based-compressor-eliminates-floating-point.txt", "jsonld": "https://wpnews.pro/news/taco-cross-platform-llm-based-compressor-eliminates-floating-point.jsonld"}}