unpkg.ai

A large language model (LLM) is a neural network trained to predict the next token in a sequence, and it generates text by repeating that prediction one token at a time. Under the hood, the text you type is split into tokens, converted into vectors (embeddings), and passed through a stack of transformer layers where an attention mechanism lets each token weigh the others. The final layer scores every possible next token, and one is selected. This explanation fits anyone who wants a working mental model of the pipeline rather than a math-heavy derivation; AnimatedLLM (animatedllm.github.io) is built specifically to visualize these internal steps.

The core components

The vocabulary is fixed, so every input and output is expressed in terms of tokens the model already knows.

From text to prediction, step by step

1. Tokenize. Input text is split into tokens. A word may become one token or several subword pieces.
2. Embed. Each token maps to a vector. Position information is added so the model knows order.
3. Pass through transformer layers. Each layer applies attention (tokens exchange information) and a feed-forward network (each position is transformed).
4. Produce logits. The final representation is projected onto the vocabulary, giving a score for every possible next token.
5. Select a token. The highest score wins under greedy decoding; sampling methods can pick lower-ranked tokens for variety.
6. Append and repeat. The chosen token is added to the sequence, and the loop runs again to produce the next one.

The expected result at each loop is a single new token; a full response is just this loop repeated.

How attention works, in plain terms

Attention answers: "for this token, which other tokens matter right now?" Each token produces a query, and every token produces a key and a value. The query is compared against all keys to get weights, and the values are combined using those weights. So a pronoun can gather information from the noun it refers to, and a verb can look back at its subject.

This is why context length matters: attention can only weigh tokens inside the window it is given. Multi-head attention runs several of these weightings in parallel so different relationships can be tracked at once.

Training vs. inference

These are the same architecture used in two different modes:

• Training: the model sees text with the next token known, predicts it, measures the error, and adjusts weights across many examples. This is where knowledge and language patterns are learned.
• Inference: weights are frozen. The model only predicts forward, token by token, with no learning. This is what happens when you use a chat model.

A useful intuition: training is studying with an answer key; inference is answering without one.

Building intuition with interactive visualizations

Reading the steps is not the same as seeing them. AnimatedLLM is an interactive resource whose stated purpose is to help you understand how large language models work under the hood. Use it to watch tokens become vectors, follow attention weights between positions, and trace how a prediction is produced. For example, if you want to see why a model completes "The cat sat on the ___" with "mat," step through the attention view to observe which earlier tokens the final position is weighting most heavily.

Common sticking points

• Tokens are not words. A single word can be multiple tokens, which is why models sometimes miscount letters.
• Embeddings are not meanings you can read off. They are learned coordinates; similarity is geometric, not definitional.
• Attention is not memory. It operates within the current context window, not a persistent store.
• One token at a time. Fluency comes from repetition, not from generating a whole sentence in one pass.

If you want to go from "I've heard of transformers" to "I can trace the pipeline," work through the tokenize → embed → attend → score → select loop once, then use an interactive demo to watch each stage on real text.

Coding is writing instructions that a computer follows to produce a result — in a creative app like Sumocode, that result is an app or a game you can build with just a few lines of code. You can start entirely in a browser: Sumocode is described as an online coding environment with gamified examples, so you can learn by playing through sample code, remix an existing example, or write something new from scratch. This guide is for complete beginners who want to try coding without installing anything, and it assumes only an internet connection and a modern browser.

What coding actually is

A program is a list of instructions. Each line tells the computer to do one small thing — show a shape, move it, check whether a key was pressed, add a point to a score. The computer does exactly what you write, in order, which is why small mistakes (a missing character, a wrong name) produce visible errors rather than silent guesses.

In a creative coding environment, those instructions usually map to things you can see immediately:

• Drawing and animation — put something on screen and change it over time.
• Input — respond to a click, tap, or key press.
• State — remember values like score, lives, or position.
• Logic — decide what happens next with conditions and repetition.

You do not need to memorize syntax first. You need a loop you can repeat: change one line, run it, look at what happened.

How browser-based coding works

A browser-based environment runs your code in the page itself. You type into an editor, press run, and the result appears in a preview area next to it. Nothing is installed on your device, and the same project opens on a phone, tablet, or computer.

Sumo describes its whole suite as cloud-based and usable with just internet access, and Sumocode sits alongside the other apps (Sumopaint, Sumotunes, Sumo3D, Sumophoto, Sumoaudio, Sumovideo, Sumopixel) in that same browser-first model. The practical consequences for a beginner:

Starting with Sumocode

The page describes three concrete entry points, and they are worth using in this order.

1. Work through the gamified examples

Gamified examples turn each concept into a small challenge. You are not reading a manual; you are changing code until something works. Expect the first examples to cover output (putting something on screen), then input, then simple logic. Do them in sequence rather than skipping ahead — each one usually depends on the last.

2. Remix a sample

"Remix" means taking an existing example and editing it as your own copy. This is the fastest way past the blank-page problem. A useful first remix:

1. Open a sample that already does something you like.
2. Change one visible value — a speed, a size, a color, a starting number.
3. Run it and confirm the change appeared.
4. Change a second value and run again.
5. Keep going until the program no longer looks like the original.

If a change breaks the program, undo it and try a smaller change. Breaking things and fixing them is the actual learning process, not a detour from it.

3. Write something from scratch

Once remixing feels comfortable, start a new file and build the smallest possible version of an idea. A game, for example, can begin as: one object on screen, one input that moves it, one condition that ends the round. Get that working before adding anything else.

What to learn first

Beginners do best with a short list of concepts rather than a full language syllabus. In a creative coding context, these come up almost immediately:

• Variables — named containers for values you want to reuse or change.
• Functions — named blocks of instructions you can run whenever you need them.
• Conditions — "if this, then that," used for collisions, scores, and game over states.
• Loops — repeating instructions, used for animation and for drawing many objects.
• Events — code that runs in response to a click or key press.

You do not need to pick a "best" language before starting. The concepts above transfer between languages, so the priority is picking an environment where you can run code and see results within seconds.

A realistic first project

Pick something small enough to finish in one sitting. For example, a clicker-style game:

1. Show a shape or character on screen.
2. Add a score variable that starts at zero.
3. Increase the score when the shape is clicked.
4. Display the score so you can see it change.
5. Add one condition — for example, a message when the score passes a threshold.

Each step is one small change you can test immediately. When it works, save it, then remix your own project into a second version with a different rule. Reusing your own working code is how the concepts stop being abstract.

Common sticking points

• Nothing happens when you run it. Usually a typo in a name or a missing character. Compare your line against the example character by character.
• It worked, then it broke. Undo your last change rather than rewriting everything. One change at a time keeps the cause obvious.
• You do not know what to build. Remix first. Original ideas come more easily once you have working code in front of you.
• You feel like you are copying. Copying working examples, then modifying them, is a standard way to learn to code — the modification is where the understanding happens.

Next steps

Move from single concepts to small finished projects: a game with a score, an animation with a loop, a tool that responds to input. Sumocode's model — gamified examples, remixing, and writing from scratch — supports that progression without leaving the browser, and the same account-based suite lets you carry what you learn into the other creative apps when a project needs images, sound, or 3D models.

Artificial insemination (AI) with frozen semen lets you breed a Connemara mare to a stallion that may be standing hundreds or thousands of miles away — or no longer alive. The trade-off is that frozen semen demands much tighter management than natural cover or fresh/chilled semen. In practice, you need a veterinarian experienced in equine reproduction, precise monitoring of the mare's cycle, and realistic expectations about success rates. This article walks through what actually happens, step by step, and helps you judge whether AI is the right route for your breeding plan.

What "AI with frozen semen" actually means

AI is simply placing semen into the mare's reproductive tract by instrument rather than by natural cover. The semen itself comes in three broad forms:

• Fresh: collected and used within hours.
• Chilled: extended and shipped, typically used within 24–48 hours.
• Frozen: processed with cryoprotectants and stored in liquid nitrogen, potentially for years.

Frozen semen is the most logistically flexible and the most biologically demanding. The freezing and thawing process kills a large proportion of sperm cells, and the survivors have a shorter functional lifespan in the mare's tract than fresh sperm. That is the single most important fact to understand before you commit.

The basic steps, in order

1. Confirm the mare is a suitable candidate

Before anything else, a reproductive examination is worthwhile. A vet typically checks:

• General health and body condition
• Reproductive tract via ultrasound and/or speculum exam
• Cervical and uterine status
• Any history of previous foaling or breeding problems
• Uterine culture or cytology if infection is suspected

Older mares, mares with a history of endometritis, or mares that have never conceived are all higher-risk. This does not rule them out, but it changes the odds and the level of veterinary input required.

2. Source the frozen semen

Frozen Connemara semen is available from some studs and via semen banks, though the pool is smaller than in warmblood or Thoroughbred breeding. When enquiring, ask for:

• Stallion registration details and studbook
• Number of doses available per breeding
• Post-thaw motility figures (a quality indicator, not a guarantee)
• Breeding contract terms, including live foal guarantees if offered
• Shipping and storage arrangements for the liquid nitrogen dewar

If you are breeding for a registered Connemara foal, check the relevant studbook's rules on AI and on frozen semen specifically. Registration bodies differ in what they accept and what documentation they require from the stallion owner.

3. Monitor the mare's cycle closely

This is where frozen semen differs most from natural cover. Because thawed sperm survive only a short time, insemination must happen very close to ovulation — often within a window of roughly 12 to 24 hours before or around ovulation, depending on the protocol your vet uses.

Typical monitoring involves:

• Teasing with a stallion or a reliable teaser to detect oestrus
• Ultrasound scanning every 24–48 hours once the mare is in season
• Tracking follicle size to predict imminent ovulation
• Possible ovulation induction with a hormone injection to tighten the timing

Some vets also use deep-horn or hysteroscopic insemination, which places a small volume of semen directly at the tip of the uterine horn. This can improve results with low-dose or poor-quality frozen samples, but it requires specialised equipment and skill.

4. Thaw and inseminate

Thawing follows the semen processor's instructions exactly — usually a specific water bath temperature and time. Deviating from the protocol damages sperm. The insemination itself is quick and is performed by the vet.

5. Post-breeding management

Depending on the mare's history, the vet may recommend:

• Oxytocin treatment to help clear fluid from the uterus
• Anti-inflammatory medication
• A post-breeding scan to confirm ovulation and check for fluid

Pregnancy is normally confirmed by ultrasound around 14–16 days after ovulation, with a follow-up check later to monitor the pregnancy.

Why timing is the hard part

With natural cover, sperm can remain viable in the mare for a day or more, so a slightly mistimed breeding still has a chance. With frozen semen, that buffer largely disappears. If you inseminate too early, the sperm are gone before the egg arrives. Too late, and the egg has already aged.

This is why frozen semen breeding is often described as a timing exercise as much as a fertility one. It also explains why success rates vary so widely between mares, cycles, and clinics. Published per-cycle pregnancy rates for frozen semen in horses are generally lower than for fresh or chilled semen, and outcomes depend heavily on mare fertility, semen quality, and the skill of the team managing the cycle.

Practical considerations before you decide

Questions to ask yourself

• Do I have a vet with equine reproduction experience nearby? Without one, frozen semen AI is impractical.
• Can I commit to frequent scanning appointments? Cycles can require several visits over a few days.
• Is the stallion I want only available frozen? If a suitable stallion is available fresh or chilled, that is usually the easier path.
• What does the studbook require? Confirm AI and frozen semen are accepted and what paperwork is needed.
• What is my budget for a possibly repeated process? Frozen semen breeding can take more than one cycle.

When AI makes sense — and when it doesn't

AI with frozen semen is a reasonable choice when:

• The stallion you want is geographically distant, deceased, or in heavy competition
• You want to preserve genetics from a specific pony
• Natural cover is impossible for health, safety, or management reasons
• You have access to good reproductive veterinary care

It is a poor fit when:

• No experienced equine vet is available
• The mare has known fertility problems and you want the easiest route
• You cannot manage the monitoring schedule
• A suitable stallion is available locally for natural cover or fresh semen

A realistic way to proceed

1. Have your mare examined and get an honest assessment of her breeding soundness.
2. Confirm the studbook's rules on AI and frozen semen.
3. Contact stallion owners or semen banks and request post-thaw quality data and contract terms.
4. Line up a reproductive vet before you buy semen, not after.
5. Plan the breeding for a time of year when you can attend appointments and when the vet's schedule allows.
6. Budget for more than one cycle, and treat the first attempt as a learning cycle rather than a certainty.

Frozen semen AI is a powerful tool for Connemara breeders, but it rewards preparation far more than improvisation. If you have the veterinary support and the patience for precise timing, it opens up stallion choices you could never access otherwise. If you don't, natural cover or fresh semen will usually be the more straightforward route to a foal.

unpkg.ai generates JavaScript ES modules on demand from a prompt embedded in the URL, then serves them as importable .js files. You use one by writing a function signature (or a short description) into a URL path and importing it directly in your code — no signup, API keys, or authentication required, per the site. It fits rapid prototyping, dynamic plugin systems, and "top-down" coding where you declare the interface you want and let an LLM fill in the implementation. It is not a fit for anything where you need reviewed, versioned, or offline-available code.

How the URL pattern works

The core endpoint is:

GET /esm/{url-encoded-prompt}.js

The prompt is the module's interface, written as a function signature. Special characters like ?, :, {, and } must be URL-encoded. The response is a JavaScript module you import like any other ESM file.

Example request:

https://unpkg.ai/esm/formatCurrency(amount:number,currency%3F:string):string.js

Breaking that down:

Importing and calling a generated module

Once you have the URL, import the named export and call it:

import { formatCurrency } from 'https://unpkg.ai/esm/formatCurrency(amount:number,currency%3F:string):string.js';

console.log(formatCurrency(1234.56, 'EUR')); // "€1,234.56"

The module is fetched over the network at import time (or bundled, depending on your toolchain), so the first load depends on the service being reachable and the LLM producing valid code.

Optional parameters: model and seed

Two query-style options are documented:

• model — choose the AI model, e.g. gpt-4 or claude-3. Optional.
• seed — a number that makes output deterministic for the same prompt, e.g. 12345. Optional.

Use seed when you want the same generated module each time — useful for caching, tests, or reproducible builds. Without it, the same prompt may yield different implementations.

A practical example: password generator

The site's example declares a richer signature with an options object and a structured return type:

import { generatePassword } from 'https://unpkg.ai/esm/generatePassword(options%3F:{length%3F:number,symbols%3F:boolean,numbers%3F:boolean,uppercase%3F:boolean,lowercase%3F:boolean}):{password:string,strength:number,feedback:string[]}.js';

const result = generatePassword({ length: 16, symbols: true });
// { password: 'K#9m$L2pQ!7vX8nR', strength: 95, feedback: ['Very strong'] }

The declared return shape ({password, strength, feedback}) tells the model what to produce. The more precisely you specify types and structure in the signature, the more predictable the generated module tends to be.

Other documented examples follow the same pattern: calculateTip returning {tip, total, perPerson}, generatePalette returning a color scheme object, and initMinesweeper returning {start, reset, getStats} for a DOM-mounted game.

When this approach makes sense — and when it doesn't

Good fit:

• Prototyping where you want a working function now and will refine later.
• Dynamic plugin systems that load modules by URL at runtime.
• Top-down development: define the API surface first, generate the body second.

Poor fit:

• Production code needing review, tests, and pinned versions.
• Offline or air-gapped environments — every import is a network fetch.
• Security-sensitive logic: generated code is LLM output and should be inspected before you trust it.

Common snags

• Encoding errors. An unencoded ? or : breaks the URL. Encode optional markers as %3F and keep the signature otherwise intact.
• Signature drift. Vague prompts produce modules that don't match your expected return shape. Spell out parameter types and the return type.
• Non-determinism. If a module changes between loads, add a seed.
• Runtime dependency. The import resolves only while the service is reachable; plan a fallback or vendor the generated file if uptime matters.

The site lists no pricing or login requirements, so treat availability and rate behavior as things to verify against the live service rather than assume.

TypeScript is a typed superset of JavaScript: every valid JavaScript program is also valid TypeScript, but TypeScript adds optional static types that a compiler checks before your code ever runs. You use it by installing the typescript package, writing .ts files, and compiling them to plain .js with the tsc command. It fits best when a codebase grows past a few files or several people, where catching type errors at build time is cheaper than debugging them at runtime. For a throwaway script, plain JavaScript is usually faster to write.

What TypeScript actually adds

TypeScript does not change how JavaScript runs. Browsers and Node.js still execute JavaScript, so the types are erased during compilation. What you gain is a checking pass:

• Static type checking — the compiler reads your annotations and flags mismatches before execution.
• Earlier error detection — mistakes like calling a method that does not exist surface in your editor or in tsc, not in production.
• Better tooling — editors use the type information for autocomplete, inline documentation, and safe rename/refactor operations.
• Self-documenting interfaces — function signatures and object shapes describe intent without extra comments.

The trade-off is a build step and some annotation overhead. Types are optional, so you can adopt them gradually.

The basic workflow

1. Install the compiler

npm install --save-dev typescript

This adds tsc to your project. You can also install it globally, but a local dev dependency keeps the version consistent across machines and CI.

2. Write a .ts file

function greet(name: string): string {
  return `Hello, ${name}`;
}

console.log(greet("Ada"));

The : string annotations tell the compiler what name and the return value must be. If you call greet(42), tsc reports an error instead of letting it fail silently at runtime.

3. Compile

npx tsc greet.ts

Expected result: a greet.js file next to the source, containing the same logic with the type annotations removed. That .js file is what Node.js or the browser runs.

4. Add a config file

For anything beyond one file, create a tsconfig.json so you do not repeat flags:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "strict": true,
    "outDir": "dist"
  },
  "include": ["src"]
}

Then just run npx tsc. strict: true turns on the stricter checks, including strictNullChecks, which is where most real-world type safety comes from. Turning it on later in a large project is painful, so enable it early.

Key features with examples

Type annotations

let count: number = 0;
let names: string[] = ["Ada", "Grace"];

Annotations can be omitted when TypeScript can infer the type, which it does for most assignments.

Interfaces

interface User {
  id: number;
  email: string;
  nickname?: string; // optional
}

function sendWelcome(user: User) {
  console.log(`Welcome, ${user.nickname ?? user.email}`);
}

An interface describes the shape an object must have. Passing an object missing id or email is a compile error.

Generics

function first<T>(items: T[]): T | undefined {
  return items[0];
}

const n = first([1, 2, 3]);      // n: number | undefined
const s = first(["a", "b"]);     // s: string | undefined

Generics let one function work across types while keeping the relationship between input and output. T is a placeholder filled in at the call site.

Using TypeScript in an existing JavaScript project

You do not have to convert everything at once:

1. Add typescript and a tsconfig.json with "allowJs": true so .js files are included.
2. Rename files to .ts one at a time, starting with the most central modules.
3. Add types to function boundaries first — parameters and return values — and let inference handle the internals.
4. Turn on strict once the obvious errors are cleared.

Most build tools and bundlers accept TypeScript through a loader or plugin, so you rarely need to run tsc by hand in a modern setup. In monorepos, tools like Lerna manage multiple JavaScript/TypeScript packages from one repository, and each package can carry its own tsconfig.json while sharing a base config. That is a common reason teams introduce TypeScript: a shared type contract between packages catches breaking changes at build time rather than at integration.

Common sticking points

• any everywhere — annotating everything as any disables the checks you installed TypeScript for. Prefer unknown and narrow it.
• Ignoring strictNullChecks — most runtime crashes come from null/undefined, which this flag catches.
• Types at runtime — TypeScript types do not exist after compilation, so you still need runtime validation for data from APIs, files, or user input.
• Build configuration drift — mismatched target/module settings between tsconfig.json and your bundler cause confusing errors; keep them aligned.

If your goal is safer JavaScript in a growing codebase, start with a tsconfig.json, enable strict, and convert files incrementally. If you are writing a small script that will not be maintained, plain JavaScript remains the simpler choice.