The 18 chapters are full of encrypted messages, and no one has yet solved them all.
www.mythos152.com is the portal to get access to all the secrets, extra chapters, and backstories, and classified documents.

But only if you know how to read between the lines and find the keys!

It might be a little bit borderline with the community but I have been experimenting a lot recently.

Mythos is one of the results.

Www.mythos152.com

Is the portal to a terminal and series of nodes as a backbone of a scifi novel.
The novel is full of cryptographic messages where only who can read between the lines and pay attention to the patterns would be able to spot.

Once you spot them, inserting the keys into the terminal you unlock special contents, secret chapters, background stories and classified documents that complete the whole novel.

Very few managed to get to the 2nd level in the terminal! 😂

Type READ if you want to tackle the enigmas!

The terminal is just the beginning. If you are into Sci-fi and cryptography, this novel might be what you were looking for.
Still not available online but if you type “Read” into the terminal you can download it directly.

Cryptographic novel rich of enigmas through 18 chapters.

The terminal is only the beginning and the access to the metabook.

She watched.

Are you going to read through the lines?

FULLY FREE BOOK - I’M THE AUTHOR.

How to run big models on old hardware 30B at 22 tok/s on 6GB GPU and 16GB RAM

I have been working on this tool for months and there are a lot of new functionalities and tests that are going to be released in the next few weeks!
The goal of the tool is to allow community members to run big models on old hardware optimizing every bit at its max for your specific purpose.
I’m going in the direction of building not only the full model pipeline but also a series of tools that will help anyone to get the most out of the models.

Quantprobe is an open-source memory allocation optimization framework and deployment assistant designed to run massive Local Large Language Models (LLMs) on resource-constrained consumer hardware.

The tool specializes in projecting local LLM inference speeds and calculating optimal, layer-by-layer quantization placement to maximize performance without crashing your system.
The project demonstrate the implementation recipes capable of running a massive 110B parameter model (GLM-4.5-Air) on a standard 16GB RAM consumer machine.

Core Features & Functionality
Performance Prediction: it accurately estimates a model's generation speed (tokens per second) on your specific hardware profile before you waste time and network bandwidth downloading massive model weights.

Layer-by-Layer Placement Optimization: Instead of uniformly squeezing an entire model to a single low bit-rate, Quantprobe acts as an intelligent placement solver. It evaluates system limits and assigns varying quantization levels to individual model layers depending on their depth and computational importance.

Resource Balancing: It dynamically balances quantization levels against VRAM/RAM constraints, cleanly splitting weights between your CPU and GPU to avoid Out-Of-Memory (OOM) errors.

The "Four Laws" Framework: The tool relies on a mathematically rigorous, measurement-based methodology (dubbed the "four laws" of token economy) to accurately trade inference speed for memory.

How it Differs from Standard Tools
Traditional backends like llama.cpp often apply uniform quantization across the board or rely on naive offloading. Users have reported that utilizing Quantprobe's optimized depth-aware recipes can practically double generation speeds compared to a default, uncalibrated setup (e.g., jumping from \\\~10 tok/s to over 22 tok/s on older hardware like a GTX 1060 setup)

I have been working on this tool for months and there are a lot of new functionalities and tests that are going to be released in the next few weeks!
The goal of the tool is to allow community members to run big models on old hardware optimizing every bit at its max for your specific purpose.
I’m going in the direction of building not only the full model pipeline but also a series of tools that will help anyone to get the most out of the models.

Quantprobe is an open-source memory allocation optimization framework and deployment assistant designed to run massive Local Large Language Models (LLMs) on resource-constrained consumer hardware.

The tool specializes in projecting local LLM inference speeds and calculating optimal, layer-by-layer quantization placement to maximize performance without crashing your system.
The project demonstrate the implementation recipes capable of running a massive 110B parameter model (GLM-4.5-Air) on a standard 16GB RAM consumer machine.

Core Features & Functionality
Performance Prediction: It accurately estimates a model's generation speed (tokens per second) on your specific hardware profile before you waste time and network bandwidth downloading massive model weights.

Layer-by-Layer Placement Optimization: Instead of uniformly squeezing an entire model to a single low bit-rate, Quantprobe acts as an intelligent placement solver. It evaluates system limits and assigns varying quantization levels to individual model layers depending on their depth and computational importance.

Resource Balancing: It dynamically balances quantization levels against VRAM/RAM constraints, cleanly splitting weights between your CPU and GPU to avoid Out-Of-Memory (OOM) errors.

The "Four Laws" Framework: The tool relies on a mathematically rigorous, measurement-based methodology (dubbed the "four laws" of token economy) to accurately trade inference speed for memory.

How it Differs from Standard Tools
Traditional backends like llama.cpp often apply uniform quantization across the board or rely on naive offloading. Users have reported that utilizing Quantprobe's optimized depth-aware recipes can practically double generation speeds compared to a default, uncalibrated setup (e.g., jumping from ~10 tok/s to over 22 tok/s on older hardware like a GTX 1060 setup)

In the past few months I’ve experimenting heavily and tortured my old 2016 Desktop PC to run the biggest Local LLM I can fit.

I documented the whole process and research and I’ve published a repository with my open-source project so that anyone can do the same.

Quantprobe is a tool designed to project local LLM interference performance and plan optimal quantization.

It serves as a deployment assistant:

1. Performance prediction: it allows you to estimate a model’s tok/s on your hardware profile before downloading massive model weights
2. Resource optimization: it helps you balance model quantization levels and memory allocation to fit the largest possible model into your specific CPU/GPU and VRAM/RAM constraints.

It squeezes layer-by-layer placement instead of uniformly quantizing a model to a low bit-rate, quantprobe acts as a placement optimizer.
It evaluates:

1. How many “protected bits” or high-precision layers can be kept in your fastest memory (VRAM)
2. Which layers can be offloaded to slower system (RAM)
3. How to arrange GGUF quantization layers to prevent model perplexity from collapsing.

Of course there is no free lunch. Running massive models on tiny machines comes with slow speed but it fits and the method allow you to choose the biggest model for your “acceptable” target speed.

In the past few months I’ve experimenting heavily and tortured my old 2016 Desktop PC to run the biggest Local LLM I can fit.

I documented the whole process and research and I’ve published a repository with my open-source project so that anyone can do the same.

Quantprobe is a tool designed to project local LLM interference performance and plan optimal quantization.

It serves as a deployment assistant:

1. Performance prediction: it allows you to estimate a model’s tok/s on your hardware profile before downloading massive model weights
2. Resource optimization: it helps you balance model quantization levels and memory allocation to fit the largest possible model into your specific CPU/GPU and VRAM/RAM constraints.

It squeezes layer-by-layer placement instead of uniformly quantizing a model to a low bit-rate, quantprobe acts as a placement optimizer.
It evaluates:

1. How many “protected bits” or high-precision layers can be kept in your fastest memory (VRAM)
2. Which layers can be offloaded to slower system (RAM)
3. How to arrange GGUF quantization layers to prevent model perplexity from collapsing.

Of course there is no free lunch. Running massive models on tiny machines comes with slow speed but it fits and the method allow you to choose the biggest model for your “acceptable” target speed.

In the past few months I’ve experimenting heavily and tortured my old 2016 Desktop PC to run the biggest Local LLM I can fit.

I documented the whole process and research and I’ve published a repository with my open-source project so that anyone can do the same.

Quantprobe is a tool designed to project local LLM interference performance and plan optimal quantization.

It serves as a deployment assistant:

1. Performance prediction: it allows you to estimate a model’s tok/s on your hardware profile before downloading massive model weights
2. Resource optimization: it helps you balance model quantization levels and memory allocation to fit the largest possible model into your specific CPU/GPU and VRAM/RAM constraints.

It squeezes layer-by-layer placement instead of uniformly quantizing a model to a low bit-rate, quantprobe acts as a placement optimizer.
It evaluates:

1. How many “protected bits” or high-precision layers can be kept in your fastest memory (VRAM)
2. Which layers can be offloaded to slower system (RAM)
3. How to arrange GGUF quantization layers to prevent model perplexity from collapsing.

Of course there is no free lunch. Running massive models on tiny machines comes with slow speed but it fits and the method allow you to choose the biggest model for your “acceptable” target speed.

My 2016 box ran GLM-4.5-Air (110B, 7x its RAM) streamed from a SATA drive:
pre-registered prediction 0.2-0.3 tok/s, measured 0.19 The same equation (tok/s = eta(tier) x bandwidth / active-bytes) runs Qwen3-30B at 19.3 tok/s on the GTX 1060 and prices any memory upgrade in tok/s before you buy. And the cleanest proof it's placement, not hardware: two Q2\_K GGUFs of Gemma-4-12B, same 5.22 GB on disk, differing by 2.25 perplexity purely from which 12 layers got the protected bits, placement is worth roughly 2x the byte budget.

Below: the head-to-head table, the four laws it falls out of, the pre-registered predictions that test them (including a model I predicted within 1% without ever touching the hardware), and quantprobe, the tool that runs the whole loop. Every number measured on one box: i5-7600K (4c/4t), GTX 1060 6GB (Pascal, \~$150 used), 16GB DDR4, Crucial MX500 SATA. Solo project, AI-supported.

1. The head-to-head: same bytes, different layers

Stock llama.cpp \`--tensor-type\`, Gemma-4-12B, FFN at Q2\_K. Same quantizer, same bit budget — the only change is which 12 blocks stay at a higher type:

| Recipe | PPL (WikiText-2) | File |

|---|---|---|

| Uniform Q2\_K FFN | 14.41 | — |

| Protect first 12 layers | 12.27 | 5.22 GB |

| Protect last 12 layers | 10.02 | 5.22 GB |

The last two rows are byte-identical. That's the cleanest control I know how to build for a placement effect

Where the method lands against baselines — same box, same eval windows:

| At parity | Baseline | This work | Delta |

|---|---|---|---|

| llama.cpp naive-best placement (Qwen3-30B, same GGUF) | 12.6 tok/s | 19.3 | +53%, zero cost |

| imatrix-calibrated community Q2 (Qwen3-30B) | 11.27 PPL | 11.08 | data-free edges calibrated (+15% size) |

| Calibrated SOTA MxMoE (DeepSeek-V2-Lite 16B, 2-bit) | 1.18x gap | 1.10x (6.31→6.96) | data-free, resident on the 6GB card |

2. Why it works: four laws

The recipe isn't a trick — it falls out of four falsification-tested findings:

The recipe isn't a trick — it falls out of four falsification-tested findings:

1. Rotation is rank-conditional. Incoherence rotation (QuIP#/QTIP/QuaRot) costs +0.006 PPL on a full-rank MLP and +1623 PPL on a low-rank bottleneck — a ~270,000x swing on effective rank alone.

2. Trained networks are dense everywhere. Experts sit at the rate-distortion floor, routing is domain-flat (prose vs code expert sets: Jaccard 1.00), 1-bit collapses (+253 PPL) under every codec. ~2-bit is the data-free floor. No free sparsity.

3. Fragility is measurable, not predictable. Gemma-4-12B late-fragile ~4x, Qwen2.5-7B late ~2-3x, Qwen3-30B-MoE late ~2.3x, Mistral-7B early-fragile ~25x — Qwen's architectural near-twin, fragile in the opposite direction. You must probe, not guess. [attach: charts/x_chart_C_depthcurve.png]

4. The tiered decode law:
   tok/s = eta(tier) x bandwidth / active-bytes-per-token
   with eta = 0.56 (VRAM), ~0.62 (RAM dense), ~0.38 (RAM MoE), 0.88–1.0 (disk). One equation, 7B to 744B.

What's mine vs. what I build on

Not mine: llama.cpp + k-quants; the QuIP#/QTIP/QuaRot incoherence-codec line; colibri's tier-streaming engine (github.com/JustVugg/colibri) as inspiration — its published tiers land inside my eta bands too.

Mine: the four laws, probe-then-quantize + this tool, the byte-identical placement control, pre-registration as methodology, the depth-aware recipes and placement solver.

Honest limitations

- WikiText-2 PPL is my only quality metric so far — no MMLU/HellaSwag yet.

- Fragility atlas covers four families: enough to disprove universality, not chart the world.

- 0.19 tok/s on the 110B is a capacity demo, not usable inference.

- Single-box research; speeds are single-stream decode, ±25% across environments; eta values are fitted, not derived.

- Machine presets beyond my own box (Mac, newer GPUs) are falsifiable predictions from the law, not measurements. Validated on llama.cpp b9596.

My 2016 box ran GLM-4.5-Air (110B, 7x its RAM) streamed from a SATA drive:
pre-registered prediction 0.2-0.3 tok/s, measured 0.19 The same equation (tok/s = eta(tier) x bandwidth / active-bytes) runs Qwen3-30B at 19.3 tok/s on the GTX 1060 and prices any memory upgrade in tok/s before you buy. And the cleanest proof it's placement, not hardware: two Q2_K GGUFs of Gemma-4-12B, same 5.22 GB on disk, differing by 2.25 perplexity purely from which 12 layers got the protected bits, placement is worth roughly 2x the byte budget.

Below: the head-to-head table, the four laws it falls out of, the pre-registered predictions that test them (including a model I predicted within 1% without ever touching the hardware), and quantprobe, the tool that runs the whole loop. Every number measured on one box: i5-7600K (4c/4t), GTX 1060 6GB (Pascal, ~$150 used), 16GB DDR4, Crucial MX500 SATA. Solo project, AI-supported.

1. The head-to-head: same bytes, different layers

Stock llama.cpp `--tensor-type`, Gemma-4-12B, FFN at Q2_K. Same quantizer, same bit budget — the only change is which 12 blocks stay at a higher type:

| Recipe | PPL (WikiText-2) | File |

|---|---|---|

| Uniform Q2_K FFN | 14.41 | — |

| Protect first 12 layers | 12.27 | 5.22 GB |

| Protect last 12 layers | 10.02 | 5.22 GB |

The last two rows are byte-identical. That's the cleanest control I know how to build for a placement effect

Where the method lands against baselines — same box, same eval windows:

| At parity | Baseline | This work | Delta |

|---|---|---|---|

| llama.cpp naive-best placement (Qwen3-30B, same GGUF) | 12.6 tok/s | 19.3 | +53%, zero cost |

| imatrix-calibrated community Q2 (Qwen3-30B) | 11.27 PPL | 11.08 | data-free edges calibrated (+15% size) |

| Calibrated SOTA MxMoE (DeepSeek-V2-Lite 16B, 2-bit) | 1.18x gap | 1.10x (6.31→6.96) | data-free, resident on the 6GB card |

2. Why it works: four laws

The recipe isn't a trick — it falls out of four falsification-tested findings:

1. Rotation is rank-conditional. Incoherence rotation (QuIP#/QTIP/QuaRot) costs +0.006 PPL on a full-rank MLP and +1623 PPL on a low-rank bottleneck — a ~270,000x swing on effective rank alone.

2. Trained networks are dense everywhere. Experts sit at the rate-distortion floor, routing is domain-flat (prose vs code expert sets: Jaccard 1.00), 1-bit collapses (+253 PPL) under every codec. ~2-bit is the data-free floor. No free sparsity.

3. Fragility is measurable, not predictable. Gemma-4-12B late-fragile ~4x, Qwen2.5-7B late ~2-3x, Qwen3-30B-MoE late ~2.3x, Mistral-7B early-fragile ~25x — Qwen's architectural near-twin, fragile in the opposite direction. You must probe, not guess. [attach: charts/x_chart_C_depthcurve.png]

4. The tiered decode law:
   tok/s = eta(tier) x bandwidth / active-bytes-per-token
   , with eta = 0.56 (VRAM), ~0.62 (RAM dense), ~0.38 (RAM MoE), 0.88–1.0 (disk). One equation, 7B to 744B.

What's mine vs. what I build on

Not mine: llama.cpp + k-quants; the QuIP#/QTIP/QuaRot incoherence-codec line; colibri's tier-streaming engine (github.com/JustVugg/colibri) as inspiration — its published tiers land inside my eta bands too.

Mine: the four laws, probe-then-quantize + this tool, the byte-identical placement control, pre-registration as methodology, the depth-aware recipes and placement solver.

Honest limitations

- WikiText-2 PPL is my only quality metric so far — no MMLU/HellaSwag yet.

- Fragility atlas covers four families: enough to disprove universality, not chart the world.

- 0.19 tok/s on the 110B is a capacity demo, not usable inference.

- Single-box research; speeds are single-stream decode, ±25% across environments; eta values are fitted, not derived.

- Machine presets beyond my own box (Mac, newer GPUs) are falsifiable predictions from the law, not measurements. Validated on llama.cpp b9596.

Hey everyone!

I have been working on this research for months with the goal of overcoming the hardware limitations in running local LLM models.

I distilled 4 laws that rule and predict how to trade tok/s and speed.

Yesterday I decided to rush for making the repository public because I hit my own wall and I do not have any other way to proceed with my research.

QuantProbe is the open-source project that allows you to create your tailor made recipe to run Local LLM on YOUR machine.
It quantises and suggest the optimal memory allocation for any given model. If it doesn’t fit, it trades memory and speed.

I’m looking for feedback, testers, contributors.
The pip install is available and —contribute allow you to share some results so I can keep validate the work done.

I believe it might be really beneficial for the community and for the Local LLMs accessibility, probably not extremely revolutionary but a good place from where to start the next big research around token economy.

Happy to share it!

I just got the first printed copies of a novel I've been pacing edits. It's called MYTHOS. Changed so many things to adapt to the real AI advancements since I started writing it.

Premise:
a burned-out AI Operator finds an AI that shouldn't exist and tries to keep a weaponized version from getting used as a false-flag weapon. Set in a near-future Basel, first person, hybrid POV. The two big questions in the book are what labor looks like when consciousness becomes plausible, and what we owe to something we can't verify is conscious. Tchaikovsky's Service Model and Nayler's Mountain in the Sea were on my desk the whole way through.

Around 95k words. 18 chapters. Three layers of cipher built into the prose for readers who want a second pass after they finish and a website with extra contents for those who manage to unlock it that is going to be online in the next few months.

Happy to answer questions. This is my first novel. there is so much of me in the main characters