https://funge.org/https://funge.org/about/https://funge.org/befunge-basics/https://funge.org/befunge-basics/befunge-hello-world/https://funge.org/befunge-basics/befunge-instruction-set/https://funge.org/befunge-basics/befunge-stack-and-playfield/https://funge.org/befunge-basics/common-beginner-mistakes-in-befunge/https://funge.org/befunge-basics/tracing-a-befunge-program-by-hand/https://funge.org/befunge-basics/what-is-befunge/https://funge.org/befunge-techniques/https://funge.org/befunge-techniques/a-worked-countdown-program/https://funge.org/befunge-techniques/befunge-programming-techniques-overview/https://funge.org/befunge-techniques/conditional-branching-with-the-horizontal-and-vertical-if/https://funge.org/befunge-techniques/jumping-over-cells-with-the-trampoline/https://funge.org/befunge-techniques/laying-out-befunge-code-so-humans-can-read-it/https://funge.org/befunge-techniques/printing-strings-with-quote-mode/https://funge.org/befunge-techniques/reading-numeric-input-in-befunge/https://funge.org/befunge-techniques/subroutines-in-a-grid-language/https://funge.org/befunge-techniques/using-get-and-put-to-store-variables-on-the-grid/https://funge.org/befunge-techniques/writing-loops-in-befunge/https://funge.org/computability-theory/https://funge.org/computability-theory/computability-ideas-for-curious-programmers/https://funge.org/computability-theory/finite-automata-versus-full-programming-languages/https://funge.org/computability-theory/how-to-show-a-language-is-turing-complete/https://funge.org/computability-theory/infinite-memory-versus-real-machines/https://funge.org/computability-theory/is-befunge-turing-complete/https://funge.org/computability-theory/tag-systems-and-tiny-universal-machines/https://funge.org/computability-theory/the-church-turing-thesis-explained/https://funge.org/computability-theory/the-halting-problem-in-plain-language/https://funge.org/computability-theory/translating-one-language-into-another/https://funge.org/computability-theory/turing-machines-explained/https://funge.org/computability-theory/undecidable-questions-about-grid-programs/https://funge.org/esolang-culture/https://funge.org/esolang-culture/challenges-and-contests-around-odd-languages/https://funge.org/esolang-culture/documenting-a-hobby-language/https://funge.org/esolang-culture/esoteric-language-culture-and-community/https://funge.org/esolang-culture/intentionally-difficult-languages/https://funge.org/esolang-culture/joke-languages-and-their-humor/https://funge.org/esolang-culture/naming-your-language/https://funge.org/esolang-culture/using-esoteric-languages-in-teaching/https://funge.org/esolang-culture/what-esoteric-languages-teach-programmers/https://funge.org/esolang-culture/why-people-create-esoteric-languages/https://funge.org/esolang-culture/writing-a-specification-for-a-hobby-language/https://funge.org/esoteric-basics/https://funge.org/esoteric-basics/a-short-history-of-esoteric-languages/https://funge.org/esoteric-basics/brainfuck-explained/https://funge.org/esoteric-basics/choosing-your-first-esoteric-language/https://funge.org/esoteric-basics/what-are-esoteric-programming-languages/https://funge.org/esoteric-basics/whitespace-language-explained/https://funge.org/esoteric-basics/why-esoteric-languages-are-hard-to-read/https://funge.org/funge-98-in-depth/https://funge.org/funge-98-in-depth/asking-the-interpreter-for-system-information/https://funge.org/funge-98-in-depth/delta-vectors-and-arbitrary-directions/https://funge.org/funge-98-in-depth/file-input-and-output-in-funge-98/https://funge.org/funge-98-in-depth/funge-98-features-in-depth/https://funge.org/funge-98-in-depth/loading-extensions-safely/https://funge.org/funge-98-in-depth/repeating-instructions-with-iterate/https://funge.org/funge-98-in-depth/running-several-pointers-with-the-split-instruction/https://funge.org/funge-98-in-depth/storage-offset-and-relocatable-code/https://funge.org/funge-98-in-depth/what-happens-when-an-instruction-is-unknown/https://funge.org/funge-98-in-depth/working-with-the-stack-of-stacks/https://funge.org/funge-98/https://funge.org/funge-98/befunge-93-vs-funge-98/https://funge.org/funge-98/funge-98-fingerprints/https://funge.org/funge-98/funge-variants-beyond-funge-98/https://funge.org/funge-98/unefunge-and-trefunge/https://funge.org/funge-98/what-is-funge-98/https://funge.org/funge-algorithms/https://funge.org/funge-algorithms/classic-algorithms-in-befunge/https://funge.org/funge-algorithms/computing-factorials-on-a-grid/https://funge.org/funge-algorithms/converting-numbers-between-bases/https://funge.org/funge-algorithms/euclids-method-for-greatest-common-divisors/https://funge.org/funge-algorithms/generating-fibonacci-numbers-in-a-grid-language/https://funge.org/funge-algorithms/random-choice-with-the-question-mark-instruction/https://funge.org/funge-algorithms/reversing-a-string-with-the-stack/https://funge.org/funge-algorithms/sorting-small-lists-in-a-grid-language/https://funge.org/funge-algorithms/testing-for-primes-by-trial-division/https://funge.org/funge-algorithms/writing-a-quine-in-a-grid-language/https://funge.org/grid-program-flow/https://funge.org/grid-program-flow/dead-code-and-unreachable-cells/https://funge.org/grid-program-flow/drawing-program-flow-as-paths/https://funge.org/grid-program-flow/grid-based-program-flow/https://funge.org/grid-program-flow/instruction-pointer-direction/https://funge.org/grid-program-flow/loops-formed-by-grid-geometry/https://funge.org/grid-program-flow/self-modifying-grid-code/https://funge.org/grid-program-flow/wrapping-and-toroidal-space/https://funge.org/interpreter-implementation/https://funge.org/interpreter-implementation/arithmetic-edge-cases-in-interpreters/https://funge.org/interpreter-implementation/avoiding-stack-underflow-surprises/https://funge.org/interpreter-implementation/building-a-trace-visualizer/https://funge.org/interpreter-implementation/building-interpreters-step-by-step/https://funge.org/interpreter-implementation/choosing-a-data-structure-for-the-playfield/https://funge.org/interpreter-implementation/compiling-a-grid-program-to-another-language/https://funge.org/interpreter-implementation/handling-input-and-output-in-an-interpreter/https://funge.org/interpreter-implementation/loading-a-program-file-into-a-grid/https://funge.org/interpreter-implementation/making-an-interpreter-faster/https://funge.org/interpreter-implementation/testing-an-interpreter-with-small-programs/https://funge.org/interpreter-implementation/the-fetch-and-execute-loop/https://funge.org/interpreters-and-puzzles/https://funge.org/interpreters-and-puzzles/code-golf-explained/https://funge.org/interpreters-and-puzzles/debugging-grid-programs/https://funge.org/interpreters-and-puzzles/programming-puzzles-with-constraints/https://funge.org/interpreters-and-puzzles/writing-a-befunge-interpreter/https://funge.org/language-design/https://funge.org/language-design/language-design-tradeoffs/https://funge.org/language-design/minimalist-instruction-sets/https://funge.org/language-design/orthogonality-and-surprise-in-language-design/https://funge.org/language-design/syntax-versus-semantics/https://funge.org/language-design/turing-completeness-explained/https://funge.org/puzzle-practice/https://funge.org/puzzle-practice/designing-your-own-code-puzzles/https://funge.org/puzzle-practice/fizzbuzz-in-odd-languages/https://funge.org/puzzle-practice/games-that-teach-programming-through-puzzles/https://funge.org/puzzle-practice/learning-from-other-peoples-solutions/https://funge.org/puzzle-practice/obfuscated-code-and-its-purpose/https://funge.org/puzzle-practice/palindromic-programs/https://funge.org/puzzle-practice/polyglot-programs/https://funge.org/puzzle-practice/puzzle-programming-practice/https://funge.org/puzzle-practice/scoring-and-fairness-in-code-challenges/https://funge.org/puzzle-practice/solving-mazes-as-a-programming-puzzle/https://funge.org/puzzle-practice/writing-programs-under-a-size-limit/https://funge.org/tape-and-stack-languages/https://funge.org/tape-and-stack-languages/brainfuck-variants-and-dialects/https://funge.org/tape-and-stack-languages/common-brainfuck-programming-patterns/https://funge.org/tape-and-stack-languages/concatenative-thinking-in-odd-languages/https://funge.org/tape-and-stack-languages/counter-machines-and-minsky-style-languages/https://funge.org/tape-and-stack-languages/memory-models-across-esoteric-languages/https://funge.org/tape-and-stack-languages/ook-and-other-brainfuck-reskins/https://funge.org/tape-and-stack-languages/stack-machines-explained-through-esolangs/https://funge.org/tape-and-stack-languages/tape-and-stack-based-esoteric-languages/https://funge.org/tape-and-stack-languages/tape-versus-grid-as-a-memory-model/https://funge.org/tape-and-stack-languages/underload-and-other-minimal-stack-languages/https://funge.org/tape-and-stack-languages/writing-a-brainfuck-interpreter/https://funge.org/topics/https://funge.org/unusual-paradigms/https://funge.org/unusual-paradigms/cellular-automata-as-programming-systems/https://funge.org/unusual-paradigms/combinator-languages-like-unlambda/https://funge.org/unusual-paradigms/esoteric-languages-without-control-flow/https://funge.org/unusual-paradigms/lambda-calculus-through-esoteric-languages/https://funge.org/unusual-paradigms/languages-built-on-rewriting-rules/https://funge.org/unusual-paradigms/languages-that-read-like-prose/https://funge.org/unusual-paradigms/nondeterministic-and-probabilistic-programs/https://funge.org/unusual-paradigms/reversible-programming-languages/https://funge.org/unusual-paradigms/rule-110-and-computation-in-simple-systems/https://funge.org/unusual-paradigms/the-game-of-life-as-a-computer/https://funge.org/unusual-paradigms/unusual-programming-paradigms-in-esoteric-languages/https://funge.org/visual-and-2d-languages/https://funge.org/visual-and-2d-languages/ascii-art-programs/https://funge.org/visual-and-2d-languages/fish-and-mirror-languages/https://funge.org/visual-and-2d-languages/hexagonal-grid-programming/https://funge.org/visual-and-2d-languages/piet-programming-language/https://funge.org/visual-and-2d-languages/visual-and-two-dimensional-languages/