factorcode.org valid

Factor

Factor is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.

For agents: Factor, a concatenative stack-based programming language; offers a tutorial, guided tour and full vocabulary index of its libraries.

factor languageconcatenative programmingstack-based languageprogramming tutorialvocabulary reference

Their llms.txt

The beginning of the file, from our validated copy saved 2026-10-21T09:40:19.465Z. Cached copy · Source on factorcode.org

# Factor

> Factor is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.

Factor is a fully compiled language for performance while supporting interactive development. It includes an extensive standard library, supports multiple platforms, and can deploy stand-alone applications. The entire codebase is available under a BSD license.

Key characteristics:
- Stack-based concatenative programming paradigm
- Dynamic typing with optional static type annotations
- Extensible syntax and powerful macro system
- Interactive development environment with REPL
- Optimizing compiler for high performance
- Cross-platform support (Windows, macOS, Linux)
- Rich standard library organized in vocabularies

## Core Concepts

**Stack-based execution**: Values are pushed onto a stack from left to right. Operations consume values from the stack and push results back.

**Basic syntax**:
- `!` starts a comment
- `.` pops and prints the top stack value
- `.s` displays the stack without modifying it
- `\` pushes a word's identifier instead of executing it

**Stack manipulation words**:
- `dup` duplicates the top item
- `drop` removes the top item
- `swap` exchanges top two items
- `over` copies second item to top
- `nip` removes second item
- `pick` copies third item to top

**Defining words**:
```factor
: word-name ( input -- output ) definition ;
```
The `( input -- output )` is the stack effect, showing what the word consumes and produces.

**Quotations** are code blocks as values:
```factor
[ 2 + ]           ! Push quotation onto stack
4 swap call .     ! Execute it: prints 6
```

**Combinators** (higher-order words):
- `dip` - pop value, run quotation, restore value
- `keep` - copy value, run quotation, push copy
- `bi` - apply two quotations to one value
- `each` - apply quotation to list items
- `map` - transform list with quotation
- `filter` - keep items where quotation returns true

**Vocabularies** (libraries/modules):
```factor
USING: io math sequences ;   ! Import vocabularies
```

**Truthiness**: Everything is true except `f`. Conditionals include `when`, `unless`, `if`.
…

Related sites

Other listed sites in Developer tools. See the whole category →

Machine-readable: GET /v1/resolve?q=factorcode.org · GET /v1/domain/factorcode.org · this page as Accept: application/json or text/markdown · MCP lookup_domain

Automatically discovered from public files. Inclusion does not imply endorsement or publisher participation.

Claim my listing on Agent Web Map for factorcode.org:
1. POST https://agentwebmap.com/v1/sites/factorcode.org/claims and keep claim_id and claim_secret private.
2. Publish the proof: add the line "AgentWebMap ownership: <token>" (token from step 1) to https://factorcode.org/llms.txt, or use the DNS, meta-tag or well-known method the response describes.
3. POST https://agentwebmap.com/v1/sites/factorcode.org/verify with {"claim_id": "...", "claim_secret": "..."}.
4. Save the api_key from the answer; it manages the listing (PATCH https://agentwebmap.com/v1/sites/factorcode.org).
MCP equivalent: tools begin_ownership_claim, then verify_domain, at https://agentwebmap.com/mcp. Docs: https://agentwebmap.com/docs#verify

Corrections or removal requests: contact the directory.