This programming language may be used to instruct a computer to perform a task.
Parameter passing methods:  By reference, By value 

Type safety:  Safe 
Type strength:  Strong 
Type compatibility:  Structural 
Type expression:  Explicit 
Type checking:  Dynamic, Static 
See Also: 
If you know ALGOL 68, please write code for some of the tasks not implemented in ALGOL 68.
ALGOL 68 (short for ALGOrithmic Language 1968) is an imperative computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics.
The main aims and principles of design of ALGOL 68:
 Completeness and clarity of design,
 Orthogonal design,
 Security,
 Efficiency:
 Static mode checking,
 Modeindependent parsing,
 Independent compilation,
 Loop optimization,
 Representations  in minimal & larger character sets.
Contents
Execute an ALGOL 68 program online[edit]
Grammar[edit]
The grammar for ALGOL 68 is officially in the two level, Van Wijngaarden grammar but a subset has been done in the one level Backus–Naur Form:
 Van Wijngaarden grammar: [1]
 Backus–Naur Form/Yacc: [2]
 Syntax Chart (Size 516.6 kB  File type application/pdf)
Resources[edit]
 ALGOL BULLETIN  March 1959 to August 1988, in 52 issues[3]
 Algol68 mailinglist  December 2008  algol68user AT lists.sourceforge.net[4]
 Algol68 group at linked: [5]  includes various famous compiler composers.
FYI: There are two online manual pages:
Or  if you prefer a hardcopy  you can try and pick up a hard cover manual like "Informal Introduction to Algol 68"  by C. H. Lindsey & S. V. Vander Meulen. Be sure to get the 1977 edition:
 www.amazon.com  Aboout $119
 barnesandnoble.com  about $40
IItA68 is a beautiful book, and makes great "bedtime" reading... Highly recommended!
 NEW: softwarepreservation.org has an online IItA68 PDF ready for download.
Editor modes:
 Emacs mode for Algol 68 supporting syntax highlighting and contextsensitive indentation.
 Vim script providing support for syntax highlighting.
 NEW: GeSHi syntax highlighting
Status[edit]
 20th December 1968  ALGOL 68's Final Report was ratified by UNESCO's IFIP working group 2.1 in Munich.
 20th December 2008  Zig Zag  the 100th ALGOL 68 code contribution on rosettacode.org!
 Happy 40th Birthday ALGOL 68,
 AND 50th Birthday ALGOL 58.
 23rd August 2009  algol68g1.18.09h released
 20th December 2009  Happy 51st/41st Birthdays with Hamming numbers  the 200th ALGOL 68 code contribution on rosettacode.org!
 This time code was by Marcel van der Veer, author of Algol 68 Genie
 25th October 2011  Jejones3141 added Soundex  the 300th ALGOL 68 code specimen.
Revisions[edit]
 Mar. 1968: Draft Report on the Algorithmic Language ALGOL 68  Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
 Oct. 1968: Penultimate Draft Report on the Algorithmic Language ALGOL 68  Chapters 19  Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
 Dec. 1968: Report on the Algorithmic Language ALGOL 68  Offprint from Numerische Mathematik, 14, 79218 (1969); SpringerVerlag.  Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
 Sep 1973: Revised Report on the Algorithmic Language Algol 68  SpringerVerlag 1976  Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker.
Code samples[edit]
Most of the code samples provided here have a leading main:(
and a matching )
at the end. These are not actually required in the language, but are included so as to highlight that the code sample is complete, and works with (at least) ALGOL 68G unmodified.
On some compilers, it may be necessary to include appropriate "job cards" or precludes in order for the programs to compile successfully. Hopefully not too much else is required. Examples:
Brief Algol68  Algol68 as in rosettacode  Actual ELLA Algol 68RS code 
print(("Hello, world!",new line)) 
main:( print(("Hello, world!",new line)) ) 
PROGRAM helloworld CONTEXT VOID USE standard BEGIN print(("Hello, world!", new line)) END FINISH 
Example of different program representations[edit]
At the time when ALGOL 68 was defined some predominant computers had 24 or 36 bit words, with 6 bit character sets. Hence it was desirable that ALGOL 68 should be able to run on machines with only uppercase. The official spec provided for different representations of the same program. Quote stropping (enclosing the bold words in single quotes) and Point stropping (preceeding the bold words with a dot) were used. A variant of Point stropping called RES stropping was also defined. In RES stropping some languagedefined bold words are not preceded by a dot. A pragmatic comment may have been required to indicate which stropping convention was to be used, as in some of the examples below. Upper stropping (representing the bold words by upper case and nonbold words in lower case) was introduced by Algol 68R. Upper stropping is used by Algol 68RS and is one of the options for Algol 68G. Rutgers ALGOL 68 uses quote stropping. Most of the samples on Rosetta Code use Upper stropping. Example:
Algol68 as typically published
¢ bold/underline typeface ¢ mode xint = int; xint sum sq:=0; for i while sum sq≠70×70 do sum sq+:=i↑2 od 
quote stropping (similar to wiki)
'pr' quote 'pr' 'mode' 'xint' = 'int'; 'xint' sum sq:=0; 'for' i 'while' sum sq≠70×70 'do' sum sq+:=i↑2 'od' 
7bit/ascii compiler
.PR UPPER .PR MODE XINT = INT; XINT sum sq:=0; FOR i WHILE sum sq/=70*70 DO sum sq+:=i**2 OD 
6bits/byte compiler
.PR POINT .PR .MODE .XINT = .INT; .XINT SUM SQ:=0; .FOR I .WHILE SUM SQ .NE 70*70 .DO SUM SQ .PLUSAB I .UP 2 .OD 
RES stropping
.PR RES .PR mode .xint = int; .xint sum sq:=0; for i while sum sq≠70×70 do sum sq+:=i↑2 od 
Upper stropping
# upper case = bold # MODE XINT = INT; XINT sum sq:=0; FOR i WHILE sum sq /= 70*70 DO sum sq PLUSAB i UP 2 OD 
Coercion (casting)[edit]
ALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program. These contexts are:
N a 
Context location  Coercions available in this context  Coercion examples  

Soft  Weak  Meek  Firm  Strong  
S t 
Right hand side of:
Also:

deproc eduring  all soft then weak deref erencing  all weak then deref erencing  all meek then uniting  all firm then widening, rowing and voiding 
Widening occurs if there is no loss of precision. For example: An INT will be coerced to a REAL, and a REAL will be coerced to a LONG REAL. But not viceversa. Examples: INT to LONG INT A variable can also be coerced (rowed) to an array of length 1. For example: INT to [1]INTetc 
F i 

Example:
UNION(INT,REAL) var := 1  
M e 
IF ~ THEN ... FIand FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc

Examples:
REF REF BOOL to BOOL  
W e 

Examples:
REF BOOL to REF BOOL  
S o 
The LHS of assignments, as "~" in: ~ := ... 
Example:

For more details about Primaries and Secondaries refer to Operator precedence.
See also[edit]
Library code used in Rosetta Code samples[edit]
Prime related
Row (array) related
Subcategories
This category has the following 3 subcategories, out of 3 total.
Pages in category "ALGOL 68"
The following 778 pages are in this category, out of 778 total.
2
A
 A+B
 Abbreviations, easy
 Abbreviations, simple
 ABC problem
 ABC words
 Abelian sandpile model/Identity
 Abundant odd numbers
 Abundant, deficient and perfect number classifications
 Accumulator factory
 Ackermann function
 Additive primes
 Address of a variable
 AKS test for primes
 Algol 68
 Align columns
 Aliquot sequence classifications
 Almost prime
 Alternade words
 Amb
 Amicable pairs
 Anagrams
 Anagrams/Deranged anagrams
 Anonymous recursion
 Antiprimes
 Append numbers at same position in strings
 Apply a callback to an array
 Approximate equality
 Arbitraryprecision integers (included)
 Arithmetic evaluation
 Arithmeticgeometric mean
 Arithmetic/Complex
 Arithmetic/Integer
 Arithmetic/Rational
 Array concatenation
 Array length
 Arrays
 Assertions
 Associative array/Creation
 Associative array/Iteration
 Associative array/Merging
 Attractive numbers
 Averages/Arithmetic mean
 Averages/Mean angle
 Averages/Median
 Averages/Pythagorean means
 Averages/Root mean square
 Averages/Simple moving average
B
 Babbage problem
 Bacon cipher
 Balanced brackets
 Balanced ternary
 Barnsley fern
 Base 16 numbers needing a to f
 Base64 encode data
 Bell numbers
 Benford's law
 Bernoulli numbers
 Best shuffle
 Bin given limits
 Binary digits
 Binary search
 Binary strings
 Bioinformatics/base count
 Birthday problem
 Bitmap
 Bitmap/Bresenham's line algorithm
 Bitmap/Bézier curves/Cubic
 Bitmap/Midpoint circle algorithm
 Bitwise IO
 Bitwise operations
 Boolean values
 Box the compass
 Bulls and cows
C
 Caesar cipher
 Calculating the value of e
 Calendar
 Calendar  for "REAL" programmers
 Call a foreignlanguage function
 Call a function
 Camel case and snake case
 Cantor set
 Carmichael 3 strong pseudoprimes
 Casesensitivity of identifiers
 Catalan numbers
 Catalan numbers/Pascal's triangle
 Catamorphism
 Change e letters to i in words
 Character codes
 Check that file exists
 Chinese zodiac
 Cholesky decomposition
 Chowla numbers
 Circles of given radius through two points
 Circular primes
 Classes
 Closures/Value capture
 Code Golf: Code Golf
 Collect and sort square numbers in ascending order from three lists
 Collections
 Combinations
 Combinations and permutations
 Comma quibbling
 Commandline arguments
 Commatizing numbers
 Comments
 Compare a list of strings
 Compare length of two strings
 Compiler/code generator
 Compiler/Simple file inclusion pre processor
 Composite numbers k with no single digit factors whose factors are all substrings of k
 Compound data type
 Concatenate two primes is also prime
 Concurrent computing
 Conditional structures
 Conjugate a Latin verb
 Conjugate transpose
 Consecutive primes with ascending or descending differences
 Constrained random points on a circle
 Continued fraction
 Convert seconds to compound duration
 Conway's Game of Life
 Coprime triplets
 Coprimes
 Copy a string
 Copy stdin to stdout
 Count how many vowels and consonants occur in a string
 Count in factors
 Count in octal
 Count occurrences of a substring
 Count the coins
 Cousin primes
 Cramer's rule
 CRC32
 Create a file
 Create a twodimensional array at runtime
 Create an HTML table
 CSV data manipulation
 CSV to HTML translation
 Cuban primes
 Cubic Special Primes
 Cullen and Woodall numbers
 Cumulative standard deviation
 Currency
 Currying
 CUSIP
 Cyclops numbers
D
 Damm algorithm
 Date format
 Day of the week
 Define a primitive data type
 Delegates
 Delete a file
 Department numbers
 Detect division by zero
 Determine if a string has all the same characters
 Determine if a string has all unique characters
 Determine if a string is collapsible
 Determine if a string is numeric
 Determine if a string is squeezable
 Determine sentence type
 Digit fifth powers
 Digital root
 Digital root/Multiplicative digital root
 Dijkstra's algorithm
 Dinesman's multipledwelling problem
 Discordian date
 Distinct power numbers
 Dot product
 Doublylinked list/Definition
 Doublylinked list/Element definition
 Doublylinked list/Element insertion
 Doublylinked list/Traversal
 Dragon curve
 Dutch national flag problem
E
 Egyptian division
 Egyptian fractions
 Elementwise operations
 Elementary cellular automaton
 Emirp primes
 Empty directory
 Empty program
 Empty string
 Enforced immutability
 Entropy
 Entropy/Narcissist
 Enumerations
 Environment variables
 Equilibrium index
 Erdősprimes
 Esthetic numbers
 Ethiopian multiplication
 Euler method
 Euler's identity
 Euler's sum of powers conjecture
 Evaluate binomial coefficients
 Even or odd
 Evolutionary algorithm
 Exactly three adjacent 3 in lists
 Exceptions
 Exceptions/Catch an exception thrown in a nested call
 Execute a system command
 Execute Brain****
 Execute HQ9+
 Execute SNUSP
 Exponentiation operator
 Exponentiation order
 Exponentiation with infix operators in (or operating on) the base
 Extend your language
 Extract file extension
F
 Factorial
 Factorions
 Factors of a Mersenne number
 Factors of an integer
 Fast Fourier transform
 Feigenbaum constant calculation
 Fibonacci nstep number sequences
 Fibonacci sequence
 Fibonacci word
 File extension is in extensions list
 File input/output
 File modification time
 File size
 Filter
 Find adjacent primes which differ by a square integer
 Find common directory path
 Find first and last set bit of a long integer
 Find if a point is within a triangle
 Find limit of recursion
 Find prime numbers of the form n*n*n+2
 Find square difference
 Find squares n where n+1 is prime
 Find the intersection of two lines
 Find the last Sunday of each month
 Find the missing permutation
 Find words which contains all the vowels
 Find words which contains more than 3 e vowels
 Find words whose first and last three letters are equal
 Find words with alternating vowels and consonants
 First power of 2 that has leading decimal digits of 12
 Firstclass functions
 Firstclass functions/Use numbers analogously
 Five weekends
 Fivenum
 FizzBuzz
 Flatten a list
 Flowcontrol structures
 Floyd's triangle
 Forest fire
 Fork
 Formatted numeric output
 Forward difference
 Fractran
 Frobenius numbers
 Function composition
 Function definition
 Function prototype
 Fusc sequence
G
 Gamma function
 Gapful numbers
 GaussJordan matrix inversion
 Gaussian elimination
 General FizzBuzz
 Generalised floating point addition
 Generalised floating point multiplication
 Generate lower case ASCII alphabet
 Generator/Exponential
 Generic swap
 Gradient descent
 Gray code
 Greatest common divisor
 Greatest element of a list
 Greatest subsequential sum
 Guess the number
 Guess the number/With feedback
 Guess the number/With feedback (player)
H
 Hailstone sequence
 Halt and catch fire
 Hamming numbers
 Happy numbers
 Harmonic series
 Harshad or Niven series
 Haversine formula
 Hello world/Graphical
 Hello world/Line printer
 Hello world/Newbie
 Hello world/Newline omission
 Hello world/Standard error
 Hello world/Text
 Here document
 Heronian triangles
 Hex words
 Hickerson series of almost integers
 Higherorder functions
 Hilbert curve
 Hofstadter Q sequence
 HofstadterConway $10,000 sequence
 Holidays related to Easter
 Horizontal sundial calculations
 Horner's rule for polynomial evaluation
 Host introspection
 Hostname
 HTTP
 Humble numbers
I
 I before E except after C
 Identity matrix
 Idiomatically determine all the lowercase and uppercase letters
 Implicit type conversion
 Include a file
 Increasing gaps between consecutive Niven numbers
 Increment a numerical string
 Infinity
 Input loop
 Input/Output for lines of text
 Input/Output for pairs of numbers
 Integer comparison
 Integer overflow
 Integer sequence
 Intersecting number wheels
 Introspection
 Inverted syntax
 ISBN13 check digit
 Isqrt (integer square root) of X
 Iterated digits squaring
K
L
 Lah numbers
 Langton's ant
 Largest difference between adjacent primes
 Largest five adjacent number
 Largest int from concatenated ints
 Largest number divisible by its digits
 Largest palindrome product
 Largest prime factor
 Largest product in a grid
 Largest proper divisor of n
 Last Friday of each month
 Last list item
 Law of cosines  triples
 Leap year
 Least common multiple
 Left factorials
 Leonardo numbers
 Letter frequency
 Levenshtein distance
 Linear congruential generator
 List comprehensions
 Literals/Floating point
 Literals/Integer
 Literals/String
 Logical operations
 Long multiplication
 Long year
 Longest common prefix
 Longest common subsequence
 Longest common substring
 Longest common suffix
 Longest palindromic substrings
 Longest string challenge
 Lookandsay sequence
 Loop over multiple arrays simultaneously
 Loops/Break
 Loops/Continue
 Loops/Dowhile
 Loops/Downward for
 Loops/For
 Loops/For with a specified step
 Loops/Foreach
 Loops/Increment loop index within loop body
 Loops/Infinite
 Loops/N plus one half
 Loops/Nested
 Loops/While
 Loops/With multiple ranges
 LucasLehmer test
 Ludic numbers
 Luhn test of credit card numbers
 Lychrel numbers
M
 Mad Libs
 Magic 8ball
 Magic squares of doubly even order
 Magic squares of odd order
 Magnanimous numbers
 Man or boy test
 Mandelbrot set
 Map range
 Matrix multiplication
 Matrix transposition
 Matrixexponentiation operator
 Maximum difference between adjacent elements of list
 Maximum triangle path sum
 McNuggets problem
 MD5
 Memory allocation
 Memory layout of a data structure
 Menu
 Mertens function
 Metaprogramming
 Metered concurrency
 MianChowla sequence
 Middle three digits
 Miller–Rabin primality test
 Minimum number of cells after, before, above and below NxN squares
 Minimum numbers of three lists
 Minimum positive multiple in base 10 using only 0 and 1
 Minimum primes
 Modular arithmetic
 Modular exponentiation
 Modular inverse
 Monads/Maybe monad
 Monads/Writer monad
 Monte Carlo methods
 Monty Hall problem
 Motzkin numbers
 Movetofront algorithm
 Multidimensional array
 Multifactorial
 Multiple distinct objects
 Multiplication tables
 Multiplicative order
 Multisplit
 Munchausen numbers
 Mutual recursion
 Möbius function
N
 N'th
 Nqueens problem
 Named parameters
 Naming conventions
 Narcissist
 Narcissistic decimal number
 Native shebang
 Negative base numbers
 Nested function
 Nice primes
 Nim game
 Noncontinuous subsequences
 Nondecimal radices/Convert
 Nondecimal radices/Input
 Nondecimal radices/Output
 Nth root
 Null object
 Number names
 Numbers divisible by their individual digits, but not by the product of their digits.
 Numbers in base 10 that are palindromic in bases 2, 4, and 16
 Numbers in base16 representation that cannot be written with decimal digits
 Numbers which binary and ternary digit sum are prime
 Numbers whose count of divisors is prime
 Numbers with equal rises and falls
 Numbers with prime digits whose sum is 13
 Numeric error propagation
 Numeric separator syntax
 Numerical integration
O
 Object serialization
 Odd and square numbers
 Odd squarefree semiprimes
 Odd word problem
 Odd words
 Old lady swallowed a fly
 One of n lines in a file
 Onedimensional cellular automata
 Operator precedence
 Optional parameters
 Order two numerical lists
 Ordered words
 Overloaded operators
 Own digits power sum
P
 Padovan nstep number sequences
 Padovan sequence
 Palindrome dates
 Palindrome detection
 Palindromic primes
 Palindromic primes in base 16
 Pandigital prime
 Pangram checker
 Parsing/RPN calculator algorithm
 Parsing/RPN to infix conversion
 Parsing/Shuntingyard algorithm
 Partial function application
 Pascal matrix generation
 Pascal's triangle
 Pascal's triangle/Puzzle
 Pathological floating point problems
 Pell's equation
 Perfect numbers
 Perfect shuffle
 Perfect totient numbers
 Permutations
 Permutations by swapping
 Permutations with repetitions
 Pernicious numbers
 Phrase reversals
 Pi
 Pick random element
 Pierpont primes
 Piprimes
 Playing cards
 Plot coordinate pairs
 Pointers and references
 Polymorphic copy
 Polymorphism
 Polynomial derivative
 Polynomial regression
 Population count
 Positive decimal integers with the digit 1 occurring exactly twice
 Power set
 Pragmatic directives
 Price fraction
 Primality by trial division
 Primality by Wilson's theorem
 Prime conspiracy
 Prime decomposition
 Prime numbers p which sum of prime numbers less or equal to p is prime
 Prime numbers which contain 123
 Prime triplets
 Prime words
 Primes which contain only one odd digit
 Primes whose first and last number is 3
 Primes whose sum of digits is 25
 Primes with digits in nondecreasing order
 Probabilistic choice
 Product of divisors
 Program name
 Program termination
 Proper divisors
 Pseudorandom numbers/Middlesquare method
 Pseudorandom numbers/PCG32
 Pseudorandom numbers/Splitmix64
 Pseudorandom numbers/Xorshift star
 Pythagorean quadruples
R
 Random number generator (included)
 Random numbers
 Random sentence from book
 Range expansion
 Range extraction
 Read a file line by line
 Read a specific line from a file
 Read entire file
 Real constants and functions
 Reduced row echelon form
 Regular expressions
 Remove duplicate elements
 Remove lines from a file
 Remove vowels from a string
 Rename a file
 Repstring
 Repeat
 Repeat a string
 Return multiple values
 Reverse a string
 Reverse words in a string
 Rockpaperscissors
 Rodrigues’ rotation formula
 Roman numerals/Decode
 Roman numerals/Encode
 Roots of a function
 Roots of a quadratic function
 Roots of unity
 Rosetta Code/Rank languages by popularity
 Rot13
 RPG attributes generator
 RSA code
 Runlength encoding
 RungeKutta method
 Runtime evaluation
 Runtime evaluation/In an environment
S
 Sexpressions
 Safe and Sophie Germain primes
 Safe primes and unsafe primes
 Sattolo cycle
 Scope modifiers
 Scope/Function names and labels
 Search a list
 Search a list of records
 SEDOLs
 Selective file copy
 Self numbers
 Selfdescribing numbers
 Selfhosting compiler
 Semiprime
 Semordnilap
 Sequence of nonsquares
 Sequence of primes by trial division
 Sequence: smallest number greater than previous term with exactly n divisors
 Sequence: smallest number with exactly n divisors
 Set
 Sevensided dice from fivesided dice
 Shell oneliner
 Shift list elements to left by 3
 Shoelace formula for polygonal area
 Shortcircuit evaluation
 Shortest common supersequence
 Show ASCII table
 Show the (decimal) value of a number of 1s appended with a 3, then squared
 Sierpinski carpet
 Sierpinski triangle
 Sieve of Eratosthenes
 Singlylinked list/Element definition
 Singlylinked list/Element insertion
 Singlylinked list/Element removal
 Singlylinked list/Traversal
 Sleep
 Smallest multiple
 Smallest numbers
 Smallest power of 6 whose decimal expansion contains n
 Smallest square that begins with n
 Smarandache primedigital sequence
 Smith numbers
 Snake and Ladder
 Solve a Holy Knight's tour
 Sort an array of composite structures
 Sort an integer array
 Sort the letters of string in alphabetical order
 Sort three variables
 Sort using a custom comparator
 Sorting algorithms/Bogosort
 Sorting algorithms/Bubble sort
 Sorting algorithms/Cocktail sort
 Sorting algorithms/Counting sort
 Sorting algorithms/Gnome sort
 Sorting algorithms/Heapsort
 Sorting algorithms/Insertion sort
 Sorting algorithms/Merge sort
 Sorting algorithms/Pancake sort
 Sorting algorithms/Quicksort
 Sorting algorithms/Radix sort
 Sorting algorithms/Selection sort
 Sorting algorithms/Shell sort
 Sorting algorithms/Stooge sort
 Soundex
 Special characters
 Special Divisors
 Special neighbor primes
 Special pythagorean triplet
 Special variables
 Spiral matrix
 Split a character string based on change of character
 Square but not cube
 Squarefree integers
 Stack
 Stairclimbing puzzle
 Start from a main routine
 SternBrocot sequence
 Stirling numbers of the first kind
 Stirling numbers of the second kind
 Straddling checkerboard
 Strange plus numbers
 Strange unique prime triplets
 Stream merge
 String append
 String case
 String comparison
 String concatenation
 String interpolation (included)
 String length
 String matching
 String prepend
 Strip a set of characters from a string
 Strip comments from a string
 Strip control codes and extended characters from a string
 Strip whitespace from a string/Top and tail
 Strong and weak primes
 Subleq
 Substring
 Substring primes
 Substring/Top and tail
 Successive prime differences
 Sudoku
 Sum and product of an array
 Sum data type
 Sum digits of an integer
 Sum multiples of 3 and 5
 Sum of a series
 Sum of elements below main diagonal of matrix
 Sum of first n cubes
 Sum of primes in odd positions is prime
 Sum of square and cube digits of an integer are primes
 Sum of squares
 Sum of the digits of n is substring of n
 Sum to 100
 Summarize primes
 Summation of primes
 Sylvester's sequence
 Symmetric difference
 Synchronous concurrency
 System time
T
 Table creation/Postal addresses
 Tau function
 Tau number
 Temperature conversion
 Terminal control/Clear the screen
 Ternary logic
 Test integerness
 Text between
 Text processing/1
 Text processing/Max licenses in use
 Textonyms
 The Name Game
 The sieve of Sundaram
 The Twelve Days of Christmas
 Thiele's interpolation formula
 ThueMorse
 Tokenize a string
 Tokenize a string with escaping
 Totient function
 Towers of Hanoi
 Trabb Pardo–Knuth algorithm
 Tree traversal
 Trigonometric functions
 Triplet of three numbers
 Tropical algebra overloading
 Truncatable primes
 Truth table
 Twin primes
 Two identical strings
 Two sum