Comparison of programming languages by type system

Last updated August 28, 2025

This is a comparison of the features of the type systems and type checking of multiple programming languages.

Brief definitions

A nominal type system means that the language decides whether types are compatible and/or equivalent based on explicit declarations and names.
A structural type system means that the language decides whether types are compatible and/or equivalent based on the definition and characteristics of the types.
Type checking determines whether and when types are verified. Static checking means that type errors are reported based on a program's text (source code). Dynamic checking means that type errors are reported based on a program's dynamic (run-time) behavior.

Language	Type safety	Type expression	Type compatibility and equivalence	Type checking
A+	strong			dynamic
ActionScript 3.0	strong	implicit with optional explicit typing		static
ABC	strong
ABAP	strong		nominal	static
Ada	strong^{[TS 1]}	explicit	nominal	static
Agda	strong		nominal	static
Aldor	weak	partially implicit^[1]		static
Alef	strong			static
ALGOL 58	strong	explicit		static
ALGOL 60	strong	explicit		static
ALGOL 68	strong	explicit	structural	static & tagged unions
ALGOL W	strong			static
Alice	strong	implicit with optional explicit		static
Alma-0				static
AmbientTalk	strong			dynamic
AMOS BASIC				static
AngelScript	strong			static
APL	strong			dynamic
AppleScript	weak			dynamic
Arc				dynamic
Assembly	?	?	?	?
AutoHotkey	typeless	N/A	N/A	N/A
AutoLISP				dynamic
Ateji PX	strong	explicit	nominal	static
AWK	weak	implicit		dynamic
B	typeless
Ballerina	strong		structural	static
Bash	?	?	?	?
BASIC	strong	explicit	nominal	static
BCPL	typeless
BeanShell	strong		nominal	dynamic
BLISS	typeless	N/A	N/A	N/A
Boo	strong	implicit with optional explicit typing		static with optional dynamic typing
Bro	strong	implicit with optional explicit typing	nominal	static
C	weak	explicit	nominal	static
C--	weak			static
C++ (ISO/IEC 14882)	strong	explicit with optional implicit typing (by using auto in C++11)	nominal	static^{[TS 2]}
C*	weak	explicit		static
C#	strong ^[2]	implicit with optional explicit typing	nominal	static^{[TS 3]}
C shell	?	?	?	?
Caml	strong	implicit with optional explicit typing		static
Cecil				dynamic with optional static typing
Clean	strong	implicit		static
Ceylon	strong			static
Chapel		implicit with optional explicit typing		static
CHILL	strong			static
ChucK	strong
Cilk	weak	explicit		static
Claire	strong	implicit with optional explicit typing		dynamic with optional static typing
Clean	strong			?
Clojure	strong	implicit with optional explicit typing		dynamic
CLU	strong
COBOL	strong	explicit	nominal	static
Cobra	strong	explicit with optional implicit typing		static with optional dynamic typing
CoffeeScript		implicit		dynamic
ColdFusion (CFML)	strong	implicit		dynamic
COMAL	strong
Common Lisp	strong	implicit with optional explicit typing	structural for implicit typing, nominal for explicit typing	dynamic, some static checking(depending on implementation)
Component Pascal	strong			static
Cool	strong	explicit		static
CORAL	strong			static
Crystal		implicit with optional explicit typing^[3]	structural	static
Cuneiform		explicit		static
Curl	strong		nominal
Curry	strong	implicit with optional explicit typing		static
Cython	strong	implicit with optional explicit typing	nominal (extension types) and structural (Python)	dynamic with optional static typing
D	weak^{[TS 4]}	explicit	nominal	static
Dart	strong^[4]	gradual typing	nominal	static with optional dynamic typing
Dylan	strong			dynamic
Eiffel	strong		nominal	static
Elixir	strong	implicit		dynamic
Erlang	strong	implicit		dynamic
Euphoria	strong	explicit, implicit with objects	nominal	static, dynamic with objects
F#	strong	implicit	nominal	static
Forth	typeless	N/A	N/A	N/A
Fortran	strong	explicit^{[TS 5]}	nominal	static
Gambas	strong	explicit	nominal
GLBasic	strong	explicit. Non-explicit declarations available through project options	nominal	static
Gleam	strong	implicit with optional explicit	nominal	static
Go ^[5]	strong	partially implicit (local type inference)	structural	static
Gosu	strong	partially implicit (local type inference)	nominal (subclassing) and structural	static
Groovy	strong	implicit with optional explicit typing		dynamic with optional static typing
Harbour	strong	implicit with optional explicit typing		dynamic
Haskell	strong	implicit with optional explicit typing	nominal^[6]^[7]	static
Haxe	strong	implicit with optional explicit typing	nominal (subclassing) and structural	static with optional dynamic typing
Io	strong	implicit		dynamic
icon	strong	implicit		dynamic
ISLISP	strong			dynamic
J	strong			dynamic
Java	strong^[8]	explicit	nominal	static
JavaScript	weak	implicit	N/A	dynamic
Julia	strong	implicit with optional explicit typing^[9]	structural for implicit typing, nominal for explicit typing	dynamic
Joy	strong			dynamic
Kotlin	strong	partially implicit (local type inference)	nominal	static
LabVIEW	strong
Lua	strong	implicit		dynamic
Maple	strong			dynamic
Mercury	strong			static
Mathematica	strong			dynamic
MATLAB M-code	strong			dynamic
Modula-2	weak^{[TS 4]}	explicit	nominal	static
Modula-3	weak^{[TS 4]}	explicit	structural	static
MUMPS (M)	typeless	N/A	N/A	N/A
Neko				dynamic
Nemerle	strong	implicit	nominal	static
NetLogo	strong	implicit		dynamic
NetRexx	strong	implicit with optional explicit		dynamic with optional static typing
newLisp		implicit		dynamic
NEWP	strong			static
Newspeak				dynamic
NewtonScript				dynamic
Nial				dynamic
Nim	strong	partially implicit (type inference)		static
Nickle	strong
Nu				dynamic
Oberon	strong	explicit	nominal	static and partially dynamic^{[TS 6]}
Objective-C	weak	explicit	nominal	dynamic with optional static typing^[10]
OCaml	strong	implicit with optional explicit typing	nominal for records,^[11] structural for objects^[7]^[12]	static
Object Pascal	strong	explicit	nominal	static
Opa	strong	implicit with optional explicit typing	structural	static
Oxygene	weak	implicit		static
Oz-Mozart	strong	implicit	structural	dynamic
Pascal	weak^{[TS 4]}	explicit	nominal	static
Perl 5		implicit		dynamic
PHP	weak	implicit with optional explicit typing	nominal	dynamic
Plus	strong	explicit	structural	static, dynamic (optional)
Prolog				dynamic
Pure				dynamic
PureScript	strong	implicit with optional explicit typing	nominal	static
Python	strong	implicit (with optional explicit typing as of 3.5)	nominal	dynamic
R		implicit		dynamic
Raku		partially implicit^{[TS 7]}		dynamic with optional static typing
REBOL	strong	implicit		dynamic
Rexx	typeless	N/A, implicit wrt numbers	N/A	static+dynamic wrt numbers
RPG	weak			static
Ruby	strong	implicit	N/A	dynamic
Rust	strong	explicit with optional implicit typing^[13]	mostly nominal	static
S				dynamic
S-Lang	strong	implicit		dynamic
Scala	strong	partially implicit (local type inference)	nominal (subclassing) and structural	static
Scheme	strong	implicit		dynamic (latent)
Seed7	strong	explicit	nominal	static
Simula	strong			static^{[TS 8]}
Smalltalk	strong	implicit		dynamic
Swift	strong	partially implicit (local type inference)	nominal (subclassing) and structural	static
Standard ML	strong	implicit with optional explicit typing	structural	static
Tcl				dynamic
TypeScript	strong	optional	structural	static
Unicon	strong	implicit		dynamic
Visual Basic	strong	implicit with optional explicit typing	nominal	static
Visual Basic (.NET)	weak^{[TS 4]}	explicit		static
Visual Prolog	strong	partially implicit	nominal	static
Wolfram Language	strong			dynamic
Windows PowerShell	strong	implicit		dynamic
XL	strong		nominal	static
Xojo	strong	explicit	nominal	static
XPath/XQuery	strong	partially implicit	nominal	dynamic with optional static typing
Language	Type safety	Type expression	Type compatibility and equivalence	Type checking

Notes

↑ Unsafe operations are well isolated by a "Unchecked_" prefix.
↑ with optional dynamic type casting (see dynamic cast)
↑ with optional dynamic type (see dynamic member lookup)
1 2 3 4 5 It is almost safe, unsafe features are not commonly used.
↑ Optionally, typing can be explicitly implied by the first letter of the identifier (known as implicit typing within the Fortran community).
↑ dynamic checking of type extensions i.e. inherited types
↑ explicit for static types
↑ optional for formal and virtual procedures

References

↑ Aldor User Guide (PDF). Aldor.org. 2002. pp. 40, 61. Retrieved 3 June 2021.
↑ https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/ ^{[ bare URL ]}
↑ "Type Inference Crystal". Crystal Language Reference. Retrieved 3 June 2021.
↑ "The Dart type system". dart.dev. Retrieved 2020-04-08.
↑ The Go Programming Language Specification
↑ Löh, Andres. "Why does Haskell not have records with structural typing?". Stack Overflow. Archived from the original on 2016-03-14. Retrieved 2020-04-13.
1 2 King, Alexis (2020-01-19). "No, dynamic type systems are not inherently more open". lexi-lambda.github.io. Archived from the original on 2020-03-01. Retrieved 2020-04-13.
↑ Sheng Liang, Gilad Bracha. Dynamic class loading in the Java virtual machine. Volume 33, Issue 10 of ACM SIGPLAN Notices, October 1998.
↑ "Types · the Julia Language". Archived from the original on 2018-07-24. Retrieved 2018-07-24.
↑ Developer.apple.com Archived June 10, 2009, at the Wayback Machine
↑ "Record · Reason". reasonml.github.io. Archived from the original on 2020-03-31. Retrieved 2020-04-13.
↑ "Structural type system", Wikipedia, 2019-03-29, retrieved 2020-04-13
↑ "rust-lang/rustc-dev-guide". GitHub. Retrieved 2020-04-08.

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.

[1] Unsafe operations are well isolated by a "Unchecked_" prefix.

[3] with optional dynamic type casting (see dynamic cast)

[5] with optional dynamic type (see dynamic member lookup)

[r2-7] 1 2 3 4 5 It is almost safe, unsafe features are not commonly used.

[9] Optionally, typing can be explicitly implied by the first letter of the identifier (known as implicit typing within the Fortran community).

[15] ynamic checking of type extensions i.e. inherited types

[19] xplicit for static types

[21] tional for formal and virtual procedures

[2] Aldor User Guide (PDF). Aldor.org. 2002. pp. 40, 61. Retrieved 3 June 2021.

[4] ttps://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/ ^{[ bare URL ]}

[6] "Type Inference Crystal". Crystal Language Reference. Retrieved 3 June 2021.

[8] "The Dart type system". dart.dev. Retrieved 2020-04-08.

[10] The Go Programming Language Specification

[11] Löh, Andres. "Why does Haskell not have records with structural typing?". Stack Overflow. Archived from the original on 2016-03-14. Retrieved 2020-04-13.

[:0-12] 1 2 King, Alexis (2020-01-19). "No, dynamic type systems are not inherently more open". lexi-lambda.github.io. Archived from the original on 2020-03-01. Retrieved 2020-04-13.

[13] Sheng Liang, Gilad Bracha. Dynamic class loading in the Java virtual machine. Volume 33, Issue 10 of ACM SIGPLAN Notices, October 1998.

[14] "Types · the Julia Language". Archived from the original on 2018-07-24. Retrieved 2018-07-24.

[16] Developer.apple.com Archived June 10, 2009, at the Wayback Machine

[17] "Record · Reason". reasonml.github.io. Archived from the original on 2020-03-31. Retrieved 2020-04-13.

[18] "Structural type system", Wikipedia, 2019-03-29, retrieved 2020-04-13

[20] "rust-lang/rustc-dev-guide". GitHub. Retrieved 2020-04-08.

[TS 1]

[1]

[TS 2]

[2]

[TS 3]

[3]

[TS 4]

[4]

[TS 5]

[5]

[6]

[7]

[8]

[9]

[TS 6]

[10]

[11]

[12]

[TS 7]

[13]

[TS 8]