N-gram Generator — Kneser–Ney - Witten–Bell

N-gram Text Generator (Kneser-Ney / Witten-Bell)

Compact trigram with backoff. Blogger-safe. ASCII only.

Corpus (training text)

Smoothing Kneser-Ney (interp) Witten-Bell (backoff)

Temperature

0.90

Seed (optional)

Max tokens

idle

---

Lempel–Ziv Text Recombination

idle

Seed text (codebook)

Mode word char

Steps

Max context (K)

Window

Novelty %

Start span

Jitter (0–1)

Min token len (word)

Output

Paste a seed text above and click Generate Text to recombine it. One-screen guarantee: the page never scrolls; long text scrolls inside this box.

How it works

Usage. Paste a source text into the Seed text box on the left, adjust the knobs if you like, then click Generate Text. The recombinant output will appear in the Output box at the bottom; you can copy just the output, or copy a full script + seed with “Copy Script.”

LZ-style recombination. Treat previously seen substrings as a codebook. At each step we take the longest suffix of current output (up to K) that appears in a rolling window (seed + prior output), grab the tokens that followed those contexts, and pick one (with light temperature).

Tips. Higher K = tighter mimic; lower K = freer remix. If it loops, raise Novelty% or Jitter, or lower K. Word mode = recombinant prosody; Char mode = texture/mimicry. Everything is ASCII-scrubbed.

Hidden Markov Model

Custom Corpus Text Generator

Hidden N-gram engine fed by your own pasted or uploaded text.

Source text (paste or type here)

Tokens: 0 Unique words: 0

Approx. output length (words)

Randomness (0.0–1.5)

Generated Output

Hidden N-Gram Text Engine

This generator runs entirely in your browser. It builds a wordbank and a layered n-gram model from whatever text you feed it.

1. Building the corpus / wordbank

• Paste text into the box and click Add to Corpus.
• Or upload a .txt file – its contents are merged automatically.
• The token and unique word counts show how large the wordbank is.

2. Hidden N-gram layers

• Visible layer: a 2-word Markov chain (bigrams). It looks at pairs of words and learns which word tends to follow.
• Hidden layer: a 3-word chain (trigrams) that tracks longer phrases in the background.
• During generation, the engine blends the visible bigram distribution with the hidden trigram distribution to choose each next word.
• If the corpus is tiny, it falls back to looser random jumps so it still produces output.

3. Controls

• Approx. output length – target number of words.
• Randomness – lower values hug the learned patterns; higher values wander into stranger regions of the chain.
• Clear Corpus – wipes the wordbank so you can start fresh.
• Copy Output – copies the generated text to your clipboard.

To increase the size and richness of the wordbank, just keep adding more text. The hidden n-gram layer quietly tracks longer spans, so as your corpus grows, the generator starts to echo your rhythms, idioms, and motifs.

Autocatalytic Text Ecosystem

[AUTO] Autocatalytic Text Ecosystem

Language as chemistry: words drift as molecules, collide, and fuse into larger phrases. Each fusion kills off its parts; phrase-sized molecules are extremely "sticky," so the bath quickly collapses into a single mega-phrase and a finished poem.

Population Seed Text Size

Arena

Temp:1.00 Reactions:0 Dominant:--

DET

ADJ

NOUN

VERB

ADV

PREP

PRON

CONJ

NP

VP

CLAUSE

Chemical Poetry

Tip: press Space to start/pause, S to step, M to pulse mutation. Bonds between compatible phrases are now almost inevitable once they get near; the bath is driven hard toward a single mega-phrase.

About: Autocatalytic Text Ecosystem

Concept. Each word is a "molecule" with reactive sites (grammatical affinities). When two molecules collide in the arena, they may bond according to an affinity table (e.g., ADJ + NOUN -> NP, DET + NOUN -> NP, NP + VERB -> CLAUSE).

Here, a successful bond is fusing and culling: both reactants vanish from the bath and a single fused phrase survives as a new molecule. No new agents are released. Phrase-level molecules (NP/VP/CLAUSE) are extremely "sticky": once there are only a few left, reactions are effectively guaranteed, so the population quickly collapses into one mega-phrase while the poem on the right records the fossil trail.

---

Emergence. Common bonds accumulate into stable "species" (metaphors, idioms, tiny clauses). Rare mutations can invent new reaction rules (novel syntax), subtly changing the path by which the bath runs down.

---

Controls.

• Start/Pause/Step run the simulation. Pulse Mutation temporarily increases rare-reaction probability.
• Reseed uses the chosen numerical Seed for reproducible runs. Population sets initial word count.
• Text Size scales all arena labels. Copy Poem copies the visible poem; Copy Log copies the full hidden reaction log.

---

Design: no circles, large readable labels with halo; one-screen layout with internal scroll for the poem. Pure JS/Canvas, no libraries.

Context-Free Grammar Evolver with Fitness Function

CFG Evolver — Growth Edition Single Screen Auto-poem + Growth Idle

Start Pop Gens K Steps Blueprint Loop Polish

Growth Enable Dup% Erase% Loop% Window lines Fitness W_len W_blue W_nov W_dup W_qual

Poem (last N lines shown; full poem copies with “Copy Poem”)

Tip: Ctrl+Enter generates; Esc cancels evolution.

Grammar EditorFormat: "term", UPPER nonterminals, {} epsilon, {br} newline, {p=0.5}

Evolver changes only the {p=} weights. Rule text stays intact.

About This App

Compatibility: This evolver uses the same rules as your Recursive Production Grammar: LHS -> RHS with | alternates, terminals in "quotes", uppercase nonterminals, epsilon {}, newline token {br}, and per-alternative weight {p=0.42}.

Workflow: Click Evolve to optimize weights; a fresh stanza is generated and the poem grows via duplicate / erase / loop-back operations.

Related: See the original Recursive Production Grammar app on SchrodingerPoetry.

Working…

Press Esc to cancel

Infinite Monkeys 5.26: Script-based random text generator

 DOWNLOAD

Word-Level PPM (Prediction by Partial Matching)

PPM Generator

Word Level

Model: none

Input (seed text)

Defaults: order=4, length=200 words, escape=1.0, seed = hash(corpus).

Output