Summary

This repository contains examples of 100+ programming languages.

Besides just showing example programs, the programs are runnable in a reproducible manner via Dockerfiles. Additionally, the programs are tested to ensure they indeed produce the expected output(s).

Screenshot

Contents

• Summary
• Screenshot
• Contents
• Contributing
• Technical background
• Help
• Usage examples
• Programs
• Checklist
• Cheating

Contributing

This project is for my personal development, so generally, pull requests aren't requested or desired.

If you'd like your language added, or would like some other change made, please open an issue.

Feel free to fork this repository and change things as you see fit!

Technical background

Podman is used to build and execute a multi-layer image.

Layer	Name	Description
1	base	Debian 13 (Trixie), common apt packages.
2	system	Things shared between all languages (entry point, tests...).
3	language	Things shared within a language (language-specific setup...).
4	program	The specific program for the language.

This provides the following (for example):

• Changing a unit test (system layer) does not require re-installing apt packages (base layer).
• Changing a language setup script (language layer) does not require rebuilding the base or system layers.
• Changing a program does not require rebuilding any other layer (base, system, or language).

Help

$ ./languages.sh --help
languages.sh 0.0.0.0

Usage:
  languages.sh [options] <command>

Options:
  --configure         Install needed dependencies, etc.
  --debug             Debug everything.
  --debug-container   Debug container building, etc.
  --debug-program     Debug program execution.
  --debug-setup       Debug language setup script.
  --help              Show this help message.
  --interactive       Begin an interaction session.
  --lean              Minimize retained images (reduces disk consumption).
  --parallel          Runs multiple programs concurrently.
  --prime             Pre-generates image(s) without running them.
  --random            Runs programs in random order.
  --reverse           Runs programs in reverse order.
  --test              Run unit tests.
  --version           Show version information.

Commands:
  clean                      Remove stored images and containers.
  list                       List languages and their programs.
  run                        Run all languages and programs.
  run <LANGUAGE>             Run all programs for a language.
  run <LANGUAGE> <PROGRAM>   Run a specific language's program.

Usage examples

• List available languages and programs:
  • ./languages.sh list
• Run everything:
  • ./languages.sh run
• Run all C# programs:
  • ./languages.sh run csharp
• Run the C# hello program:
  • ./languages.sh run csharp hello
• Debug the C# hello program:
  • ./languages.sh --debug run csharp hello
• Enter interactive mode for C#, with the hello program loaded:
  • ./languages.sh --interactive csharp hello
• Run tests for Rust (all programs):
  • ./languages.sh --test run rust
• Help/usage:
  • ./languages.sh --help
• Version:
  • ./languages.sh --version

Programs

Name	Description	Details
hello	Toolchain test.	Link
sum	Basic logic/control.	Link
math	Computation suite.	Link
microwave	Varied inputs/logic.	Link
freestyle	Show unique language features.	Link

Checklist

📁	Language	hello	sum	math	microwave	freestyle
📁	Active Oberon	⬜	⬜	⬜	⬜	⬜
📁	Ada	✅	✅	⬜	⬜	⬜
📁	Admiran	✅	✅	⬜	⬜	⬜
📁	Agda	✅	✅	⬜	⬜	⬜
📁	Algol (60)¹	✅️	✅️	⬜	⬜	⬜
📁	Algol (68)	✅️	✅	⬜	⬜	⬜
📁	Alumina	✅️	✅️	⬜	⬜	⬜
📁	AngelScript	⬜	⬜	⬜	⬜	⬜
📁	Ante	⬜	⬜	⬜	⬜	⬜
📁	APL	✅️	✅️	⬜	⬜	⬜
📁	Ark	⬜	⬜	⬜	⬜	⬜
📁	Arturo	✅	✅	⬜	⬜	⬜
📁	Asphalt	⬜	⬜	⬜	⬜	⬜
📁	Assembly (GNU)	✅	✅	⬜	⬜	⬜
📁	Assembly (Microsoft)	✅	✅	⬜	⬜	⬜
📁	Assembly (Netwide)	✅	✅	⬜	⬜	⬜
📁	AssemblyScript	⬜	⬜	⬜	⬜	⬜
📁	Atlas Autocode	⬜	⬜	⬜	⬜	⬜
📁	ATS	⬜	⬜	⬜	⬜	⬜
📁	Austral	✅	✅	⬜	⬜	⬜
📁	Awk	✅	✅	⬜	⬜	⬜
📁	Axum	⬜	⬜	⬜	⬜	⬜
📁	B	✅	✅	⬜	⬜	⬜
📁	B4X	⬜	⬜	⬜	⬜	⬜
📁	Ballerina	✅	✅	⬜	⬜	⬜
📁	Bash	✅	✅	⬜	✅	✅
📁	BASIC (Amiga)	⬜	⬜	⬜	⬜	⬜
📁	BASIC (BBC)¹	✅	✅	⬜	⬜	⬜
📁	BASIC (Commodore)	⬜	⬜	⬜	⬜	⬜
📁	BASIC (Pure)	✅	✅	⬜	⬜	⬜
📁	BASIC (QuickBASIC)¹	✅	✅	⬜	⬜	⬜
📁	Batch	✅	✅	⬜	⬜	⬜
📁	Bau	✅	✅	⬜	⬜	⬜
📁	BCPL	✅	✅	⬜	⬜	⬜
📁	Beanshell	✅	✅	⬜	⬜	⬜
📁	Beef	✅	✅	⬜	⬜	⬜
📁	Bend	⬜	⬜	⬜	⬜	⬜
📁	Blazin' Forth	⬜	⬜	⬜	⬜	⬜
📁	BLISS	⬜	⬜	⬜	⬜	⬜
📁	Boron	⬜	⬜	⬜	⬜	⬜
📁	Brainf#ck	✅	⬜	⬜	⬜	⬜
📁	C	✅	✅	⬜	✅	⬜
📁	C2	✅	✅	⬜	⬜	⬜
📁	C3	✅	✅	⬜	⬜	⬜
📁	Cakelisp	⬜	⬜	⬜	⬜	⬜
📁	CAL	⬜	⬜	⬜	⬜	⬜
📁	Caml	✅	✅	⬜	⬜	⬜
📁	Carbon	✅	✅	⬜	⬜	⬜
📁	Carp	⬜	⬜	⬜	⬜	⬜
📁	Ceylon	⬜	⬜	⬜	⬜	⬜
📁	Chapel	✅	✅	⬜	✅	⬜
📁	ChucK	✅	✅	⬜	⬜	✅
📁	Clean	⬜	⬜	⬜	⬜	⬜
📁	Clojure	✅	✅	⬜	⬜	⬜
📁	CLU	✅	✅	⬜	⬜	⬜
📁	C--	⬜	⬜	⬜	⬜	⬜
📁	CMS-2	⬜	⬜	⬜	⬜	⬜
📁	COBOL (68)	⬜	⬜	⬜	⬜	⬜
📁	COBOL (74)	⬜	⬜	⬜	⬜	⬜
📁	COBOL (85)	✅	✅	⬜	⬜	⬜
📁	Cobra	✅	✅	⬜	⬜	⬜
📁	CoffeeScript	✅	✅	⬜	⬜	⬜
📁	ColdFusion	✅	✅	⬜	⬜	⬜
📁	Component Pascal	⬜	⬜	⬜	⬜	⬜
📁	Concrete	⬜	⬜	⬜	⬜	⬜
📁	Cone	⬜	⬜	⬜	⬜	⬜
📁	Control Language	⬜	⬜	⬜	⬜	⬜
📁	Coral	⬜	⬜	⬜	⬜	⬜
📁	CORAL (CORAL 66)	⬜	⬜	⬜	⬜	⬜
📁	Cowgol	✅	✅	⬜	⬜	⬜
📁	CPL	⬜	⬜	⬜	⬜	⬜
📁	C++	✅	✅	⬜	✅	⬜
📁	Crystal	✅	✅	⬜	⬜	⬜
📁	C#	✅	✅	⬜	✅	⬜
📁	Csound	✅	✅	⬜	⬜	✅
📁	CSS¹	✅	✅	⬜	⚠️	⬜
📁	Cwerg	✅	✅	⬜	✅	⬜
📁	Cyber	✅	✅	⬜	⬜	⬜
📁	Cyclone	⬜	⬜	⬜	⬜	⬜
📁	D	✅	✅	⬜	✅	⬜
📁	Dafny	⬜	⬜	⬜	⬜	⬜
📁	Dart	✅	✅	⬜	⬜	⬜
📁	Daslang	✅	✅	⬜	⬜	⬜
📁	dBase	⬜	⬜	⬜	⬜	⬜
📁	Delphi	✅	✅	⬜	⬜	⬜
📁	Duck	⬜	⬜	⬜	⬜	⬜
📁	Dylan	✅	✅	⬜	⬜	⬜
📁	E	✅	✅	⬜	⬜	⬜
📁	eC	⬜	⬜	⬜	⬜	⬜
📁	Edinburgh IMP	⬜	⬜	⬜	⬜	⬜
📁	Effekt	⬜	⬜	⬜	⬜	⬜
📁	Eiffel	✅	✅	⬜	⬜	⬜
📁	Elixir	✅	✅	⬜	⬜	⬜
📁	Elk (A)	✅	✅	⬜	⬜	⬜
📁	Elk (B)	✅	✅	⬜	⬜	⬜
📁	Elm	✅	✅	⬜	⬜	⬜
📁	Emacs Lisp	✅	✅	⬜	⬜	⬜
📁	Erde	✅	✅	⬜	⬜	⬜
📁	Erlang	✅	✅	⬜	⬜	⬜
📁	Euclid	⬜	⬜	⬜	⬜	⬜
📁	EXA (TEC Redshift)	⬜	⬜	⬜	⬜	⬜
📁	Extempore	⬜	⬜	⬜	⬜	⬜
📁	Factor	✅	✅	⬜	⬜	⬜
📁	fe	⬜	⬜	⬜	⬜	⬜
📁	Fennel	⬜	⬜	⬜	⬜	⬜
📁	Fifth	✅	✅	⬜	⬜	⬜
📁	FL	⬜	⬜	⬜	⬜	⬜
📁	Flint	✅	✅	⬜	✅	⬜
📁	Flix	⬜	⬜	⬜	⬜	⬜
📁	FLOW-MATIC¹	✅	✅	⬜	⬜	⬜
📁	Flower	✅	✅	⬜	⬜	⬜
📁	Flux	⬜	⬜	⬜	⬜	⬜
📁	FOCAL	⬜	⬜	⬜	⬜	⬜
📁	Forth	✅	✅	⬜	⬜	⬜
📁	Fortran	✅	✅	⬜	⬜	⬜
📁	FoxPro	⬜	⬜	⬜	⬜	⬜
📁	FP	⬜	⬜	⬜	⬜	⬜
📁	FreeMarker	✅	✅	⬜	⬜	⬜
📁	F#	✅	✅	⬜	⬜	⬜
📁	F*	⬜	⬜	⬜	⬜	⬜
📁	Futhark	⚠️	✅	⬜	⬜	⬜
📁	G-Portugol	✅	✅	⬜	⬜	⬜
📁	Gambas	⬜	⬜	⬜	⬜	⬜
📁	GAMS	⬜	⬜	⬜	⬜	⬜
📁	GAP	⬜	⬜	⬜	⬜	⬜
📁	GDScript	⬜	⬜	⬜	⬜	⬜
📁	Gforth	⬜	⬜	⬜	⬜	⬜
📁	Gleam	✅️	✅️	⬜	⬜	⬜
📁	Glim	⬜	⬜	⬜	⬜	⬜
📁	Go	✅️	✅	⬜	⬜	⬜
📁	Groovy	✅️	✅	⬜	⬜	⬜
📁	Gurgle	⬜	⬜	⬜	⬜	⬜
📁	Hack	✅	✅	⬜	⬜	⬜
📁	HAL/S	⬜	⬜	⬜	⬜	⬜
📁	Hare	✅	✅	⬜	⬜	⬜
📁	Haskell	✅	✅	⬜	⬜	⬜
📁	Haxe	✅	✅	⬜	⬜	⬜
📁	Hazel	⬜	⬜	⬜	⬜	⬜
📁	HolyC	✅	✅	⬜	✅	⬜
📁	Hope	⬜	⬜	⬜	⬜	⬜
📁	Hopper	⬜	⬜	⬜	⬜	⬜
📁	HTML¹	✅	⚠️	⚠️	⚠️	⬜
📁	Hy	⬜	⬜	⬜	⬜	⬜
📁	Hylo	✅	✅	⬜	⬜	⬜
📁	HyperTalk	⬜	⬜	⬜	⬜	⬜
📁	Icon	✅	✅	⬜	⬜	⬜
📁	Idris	✅	✅	⬜	⬜	⬜
📁	Inform	✅	✅	⬜	⬜	⬜
📁	Ink	✅	✅	⬜	⬜	⬜
📁	Inko	✅	✅	⬜	⬜	⬜
📁	INTERCAL	⬜	⬜	⬜	⬜	⬜
📁	Io	✅	✅	⬜	⬜	⬜
📁	Isabelle¹	✅	✅	⬜	⬜	⬜
📁	J	⬜	⬜	⬜	⬜	⬜
📁	Janet	⬜	⬜	⬜	⬜	⬜
📁	Jank	⬜	⬜	⬜	⬜	⬜
📁	Janus	⬜	⬜	⬜	⬜	⬜
📁	Java	✅	✅	⬜	✅	⬜
📁	JavaScript	✅	✅	⬜	✅	⬜
📁	Jinja2	✅	✅	⬜	⬜	⬜
📁	JOSS	⬜	⬜	⬜	⬜	⬜
📁	Joule	⬜	⬜	⬜	⬜	⬜
📁	JOVIAL	✅	✅	⬜	⬜	⬜
📁	Joy¹	✅	✅	⬜	⬜	⬜
📁	JScript	⬜	⬜	⬜	⬜	⬜
📁	J#	⬜	⬜	⬜	⬜	⬜
📁	JS++	⬜	⬜	⬜	⬜	⬜
📁	Jtw	⬜	⬜	⬜	⬜	⬜
📁	Jule	⬜	⬜	⬜	⬜	⬜
📁	Julia	✅	✅	⬜	⬜	⬜
📁	Kairo	⬜	⬜	⬜	⬜	⬜
📁	Kip	✅	✅	⬜	⬜	⬜
📁	Kit	⬜	⬜	⬜	⬜	⬜
📁	Kitten	⬜	⬜	⬜	⬜	⬜
📁	Koka	⬜	⬜	⬜	⬜	⬜
📁	Kotlin	✅	✅	⬜	⬜	⬜
📁	KRC	⬜	⬜	⬜	⬜	⬜
📁	LabVIEW	⬜	⬜	⬜	⬜	⬜
📁	Ladder Logic	⬜	⬜	⬜	⬜	⬜
📁	Language 84	✅	⬜	⬜	⬜	⬜
📁	LDPL	⬜	⬜	⬜	⬜	⬜
📁	Lean	⬜	⬜	⬜	⬜	⬜
📁	Less¹	✅	✅	⬜	⬜	⬜
📁	Lil	⬜	⬜	⬜	⬜	⬜
📁	Lily (A)	✅	✅	⬜	⬜	⬜
📁	Lily (B)	✅	✅	⬜	⬜	⬜
📁	Lisp	✅	✅	⬜	⬜	⬜
📁	LitaC	⬜	⬜	⬜	⬜	⬜
📁	LLVM IR	✅	⬜	⬜	⬜	⬜
📁	LO	✅	✅	⬜	⬜	⬜
📁	Lobster	✅	✅	⬜	⬜	⬜
📁	Logo	✅	✅	⬜	⬜	⬜
📁	LOLCODE	✅	✅	⬜	⬜	⬜
📁	Lua	✅	✅	⬜	⬜	⬜
📁	Lucia	⬜	⬜	⬜	⬜	⬜
📁	Lucid	⬜	⬜	⬜	⬜	⬜
📁	MaoLang	⬜	⬜	⬜	⬜	⬜
📁	Maple	⬜	⬜	⬜	⬜	⬜
📁	MATLAB	✅	✅	⬜	⬜	⬜
📁	Maxima	⬜	⬜	⬜	⬜	⬜
📁	Mesa	⬜	⬜	⬜	⬜	⬜
📁	MetaOCaml	⬜	⬜	⬜	⬜	⬜
📁	Min	⬜	⬜	⬜	⬜	⬜
📁	MiniLang	⬜	⬜	⬜	⬜	⬜
📁	Miranda	⬜	⬜	⬜	⬜	⬜
📁	Modelica	⬜	⬜	⬜	⬜	⬜
📁	Modula-2	✅	✅	⬜	⬜	⬜
📁	Modula-3	⬜	⬜	⬜	⬜	⬜
📁	Modula	⬜	⬜	⬜	⬜	⬜
📁	Mojo	✅	✅	⬜	⬜	⬜
📁	MoonScript	✅	✅	⬜	⬜	⬜
📁	Mouse-83	⬜	⬜	⬜	⬜	⬜
📁	Move	⬜	⬜	⬜	⬜	⬜
📁	MUMPS (M)	⬜	⬜	⬜	⬜	⬜
📁	Myrddin	⬜	⬜	⬜	⬜	⬜
📁	Napier88	⬜	⬜	⬜	⬜	⬜
📁	NATURAL	⬜	⬜	⬜	⬜	⬜
📁	Nature	⬜	⬜	⬜	⬜	⬜
📁	Neat	⬜	⬜	⬜	⬜	⬜
📁	Nelua	✅	✅	⬜	⬜	⬜
📁	Nemerle	✅	✅	⬜	⬜	⬜
📁	Never	✅	✅	⬜	⬜	⬜
📁	Newspeak	⬜	⬜	⬜	⬜	⬜
📁	Nial	✅	✅	⬜	⬜	⬜
📁	Nim	✅	✅	⬜	✅	⬜
📁	Nit	⬜	⬜	⬜	⬜	⬜
📁	Niva	⬜	⬜	⬜	⬜	⬜
📁	Nix	✅	✅	⬜	⬜	⬜
📁	Nospace	✅	⬜	⬜	⬜	⬜
📁	NPL	⬜	⬜	⬜	⬜	⬜
📁	NSK	⬜	⬜	⬜	⬜	⬜
📁	NXT-G	⬜	⬜	⬜	⬜	⬜
📁	Oak	✅	✅	⬜	⬜	⬜
📁	Oberon	✅	✅	⬜	⬜	⬜
📁	Oberon-07	⬜	⬜	⬜	⬜	⬜
📁	Oberon-2	⬜	⬜	⬜	⬜	⬜
📁	Oberon+	✅	✅	⬜	⬜	⬜
📁	Object Pascal	✅	✅	⬜	⬜	⬜
📁	Objective-C	✅	✅	⬜	⬜	⬜
📁	Obliq	⬜	⬜	⬜	⬜	⬜
📁	OCaml	✅	✅	⬜	⬜	⬜
📁	Ocen	⬜	⬜	⬜	⬜	⬜
📁	Odin	✅	✅	⬜	✅	⬜
📁	K (oK)	⬜	⬜	⬜	⬜	⬜
📁	Oni	✅	✅	⬜	⬜	⬜
📁	Opa	⬜	⬜	⬜	⬜	⬜
📁	OpenCL	⬜	⬜	⬜	⬜	⬜
📁	Orwell	⬜	⬜	⬜	⬜	⬜
📁	Oxygene	⬜	⬜	⬜	⬜	⬜
📁	Par	✅	✅	⬜	⬜	⬜
📁	ParaSail	⬜	⬜	⬜	⬜	⬜
📁	Pascal	✅	✅	⬜	⬜	⬜
📁	Pastel	⬜	⬜	⬜	⬜	⬜
📁	Perl	✅	✅	⬜	⬜	⬜
📁	Phix	⬜	⬜	⬜	⬜	⬜
📁	PHL	⬜	⬜	⬜	⬜	⬜
📁	PHP	✅	✅	⬜	⬜	⬜
📁	Pico	✅	✅	⬜	⬜	⬜
📁	Pie	⬜	⬜	⬜	⬜	⬜
📁	Piet	⬜	⬜	⬜	⬜	⬜
📁	Pike	⬜	⬜	⬜	⬜	⬜
📁	Pkl	⬜	⬜	⬜	⬜	⬜
📁	PL-6	⬜	⬜	⬜	⬜	⬜
📁	PL.8	⬜	⬜	⬜	⬜	⬜
📁	PL/B	⬜	⬜	⬜	⬜	⬜
📁	PL/C	⬜	⬜	⬜	⬜	⬜
📁	PL/I	⬜	⬜	⬜	⬜	⬜
📁	PL/M¹	✅	✅	⬜	⬜	⬜
📁	PL/S	⬜	⬜	⬜	⬜	⬜
📁	PL/SQL	⬜	⬜	⬜	⬜	⬜
📁	Plankalkül¹	✅	✅	⬜	⬜	⬜
📁	Planner	⬜	⬜	⬜	⬜	⬜
📁	Plasm	⬜	⬜	⬜	⬜	⬜
📁	Pony	✅	✅	⬜	⬜	⬜
📁	POP-11	⬜	⬜	⬜	⬜	⬜
📁	PostScript	✅	✅	⬜	⬜	⬜
📁	Power Fx	⬜	⬜	⬜	⬜	⬜
📁	PowerShell	✅	✅	⬜	⬜	⬜
📁	PreScheme	⬜	⬜	⬜	⬜	⬜
📁	Project Verona	⬜	⬜	⬜	⬜	⬜
📁	Prolog	✅	✅	⬜	⬜	⬜
📁	PS-algol	⬜	⬜	⬜	⬜	⬜
📁	Pure	⬜	⬜	⬜	⬜	⬜
📁	PureScript	⬜	⬜	⬜	⬜	⬜
📁	Python	✅	✅	⬜	⬜	⬜
📁	Q	⬜	⬜	⬜	⬜	⬜
📁	قلب (Qalb)	✅	⬜	⬜	⬜	⬜
📁	Quackery¹	✅	✅	⬜	⬜	⬜
📁	Quetite	⬜	⬜	⬜	⬜	⬜
📁	R	✅	✅	⬜	⬜	⬜
📁	Racket	✅	✅	⬜	⬜	⬜
📁	Raku	✅	✅	⬜	⬜	⬜
📁	Reason	⬜	⬜	⬜	⬜	⬜
📁	Rebol	⬜	⬜	⬜	⬜	⬜
📁	Red	⬜	⬜	⬜	⬜	⬜
📁	RetroForth	⬜	⬜	⬜	⬜	⬜
📁	Rexx	✅	✅	⬜	⬜	⬜
📁	Ring	⬜	⬜	⬜	⬜	⬜
📁	Roc	✅	✅	⬜	⬜	⬜
📁	Rocq	⬜	⬜	⬜	⬜	⬜
📁	RPG (IV)	✅	✅	⬜	⬜	⬜
📁	RPL	⬜	⬜	⬜	⬜	⬜
📁	RTL/2	⬜	⬜	⬜	⬜	⬜
📁	RTL	⬜	⬜	⬜	⬜	⬜
📁	Ruby	✅	✅	⬜	⬜	⬜
📁	Rust	✅	✅	⬜	✅	⬜
📁	Rye	✅	✅	⬜	⬜	⬜
📁	S-algol	⬜	⬜	⬜	⬜	⬜
📁	SAS	⬜	⬜	⬜	⬜	⬜
📁	SASL	⬜	⬜	⬜	⬜	⬜
📁	Sass¹	✅	✅	⬜	⬜	⬜
📁	Sather	⬜	⬜	⬜	⬜	⬜
📁	Scala	✅	✅	⬜	⬜	⬜
📁	Scheme	✅	✅	⬜	⬜	⬜
📁	Scopes	⬜	⬜	⬜	⬜	⬜
📁	Scratch	⬜	⬜	⬜	⬜	⬜
📁	SectorLISP	⬜	⬜	⬜	⬜	⬜
📁	Sed	✅	✅	⬜	⬜	⬜
📁	Seed7	✅	✅	⬜	⬜	⬜
📁	Self	⬜	⬜	⬜	⬜	⬜
📁	Shen	⬜	⬜	⬜	⬜	⬜
📁	SIC-1	⬜	⬜	⬜	⬜	⬜
📁	Sieve¹	✅	⚠️	⚠️	⚠️	✅
📁	Silk	⬜	⬜	⬜	⬜	⬜
📁	Simula	✅	✅	⬜	⬜	⬜
📁	SmallJS	⬜	⬜	⬜	⬜	⬜
📁	Smalltalk	✅	✅	⬜	⬜	⬜
📁	Solidity	⬜	⬜	⬜	⬜	⬜
📁	Sonic Pi	⬜	⬜	⬜	⬜	⬜
📁	SPARK	✅	✅	⬜	⬜	⬜
📁	Sparrow	⬜	⬜	⬜	⬜	⬜
📁	Spin (Parallax)	⬜	⬜	⬜	⬜	⬜
📁	SQL¹	✅	✅	⬜	✅	⬜
📁	Squeak	⬜	⬜	⬜	⬜	⬜
📁	Squirrel	⬜	⬜	⬜	⬜	⬜
📁	Standard ML¹	✅	✅	⬜	⬜	⬜
📁	Stata	⬜	⬜	⬜	⬜	⬜
📁	Storm	⬜	⬜	⬜	⬜	⬜
📁	STRINGCOMP	⬜	⬜	⬜	⬜	⬜
📁	Structured Text	⬜	⬜	⬜	⬜	⬜
📁	Subleq	⬜	⬜	⬜	⬜	✅
📁	SuperCollider	✅	✅	⬜	⬜	✅
📁	Swift	✅	✅	⬜	⬜	⬜
📁	SYMPL	⬜	⬜	⬜	⬜	⬜
📁	T3X/0	✅	✅	⬜	⬜	⬜
📁	Tailspin	✅	✅	⬜	⬜	⬜
📁	Tampio¹	✅	⬜	⬜	⬜	⬜
📁	Tcl	✅	✅	⬜	⬜	⬜
📁	Teal	⬜	⬜	⬜	⬜	⬜
📁	Teascript	✅	✅	⬜	⬜	⬜
📁	TELCOMP	⬜	⬜	⬜	⬜	⬜
📁	Tern	⬜	⬜	⬜	⬜	⬜
📁	Terra	⬜	⬜	⬜	⬜	⬜
📁	TH1	⬜	⬜	⬜	⬜	⬜
📁	Toi	✅	✅	⬜	⬜	⬜
📁	Transact-SQL	⬜	⬜	⬜	⬜	⬜
📁	TriC	⬜	⬜	⬜	⬜	⬜
📁	Typescript	✅	✅	⬜	⬜	⬜
📁	Uiua	⬜	⬜	⬜	⬜	⬜
📁	Unicon	⬜	⬜	⬜	⬜	⬜
📁	Unison	✅	✅	⬜	⬜	⬜
📁	Uxntal	⬜	⬜	⬜	⬜	⬜
📁	V	✅	✅	⬜	⬜	⬜
📁	Vala	✅	✅	⬜	⬜	⬜
📁	Vale	✅	✅	⬜	⬜	⬜
📁	Varyx	✅	✅	⬜	⬜	⬜
📁	VBScript	✅	✅	⬜	⬜	⬜
📁	Verilog	✅	✅	⬜	⬜	⬜
📁	Veryl	⬜	⬜	⬜	⬜	⬜
📁	VHDL	✅	✅	⬜	⬜	⬜
📁	Visual Basic (6)	⛔	⬜	⬜	⬜	⬜
📁	Visual Basic (.NET)	✅	✅	⬜	⬜	⬜
📁	Vox	✅	✅	⬜	⬜	⬜
📁	vvvv	⬜	⬜	⬜	⬜	⬜
📁	wax	⬜	⬜	⬜	⬜	⬜
📁	文言 (Wenyan)	✅	⛔	⬜	⬜	⬜
📁	Whiley	✅	✅	⬜	⬜	⬜
📁	Whitespace	✅	⬜	⬜	⬜	⬜
📁	Wolfram	✅	✅	⬜	⬜	⬜
📁	Wren	✅	✅	⬜	⬜	⬜
📁	X10	✅	✅	⬜	⬜	⬜
📁	XOD	⬜	⬜	⬜	⬜	⬜
📁	Xojo	✅	✅	⬜	⬜	⬜
📁	XS	✅	✅	⬜	⬜	✅
📁	XSLT	⬜	⬜	⬜	⬜	⬜
📁	Xtend	✅	✅	⬜	⬜	⬜
📁	ylang	✅	✅	⬜	⬜	⬜
📁	YSH	✅	✅	⬜	⬜	⬜
📁	Zen C	✅	✅	⬜	⬜	⬜
📁	Zig	✅	✅	⬜	✅	⬜
📁	Zonnon	✅	✅	⬜	⬜	⬜
	Count...	192	183	0	16	6

Legend

Symbol	Meaning
✅	Completed
⚠️	Unimplementable
⛔	Failing
⬜	Unimplemented
¹	"Cheating" required.

Cheating

Some programs require "cheating" to express output and/or pass tests.

See the cheating page for additional information.