For other uses, see Tcl (disambiguation).
Paradigm multi-paradigm: object-oriented, functional, procedural, event-driven programming, imperative
Designed by John Ousterhout
Developer Tcl Core Team[1]
First appeared 1988 (1988)
Stable release
8.6.6[2] / July 27, 2016 (2016-07-27)
Typing discipline dynamic typing, everything can be treated as a string
License BSD-style[3]
Filename extensions .tcl, .tbc[4]
Major implementations
Influenced by
AWK, Lisp
PHP,[5] Tea, PowerShell[6]

Tcl (pronounced "tickle" or tee cee ell, /ˈt s ɛl/) is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful.[7] Tcl casts everything into the mold of a command, even programming constructs like variable assignment and procedure definition.[8] Tcl supports multiple programming paradigms, including object-oriented, imperative and functional programming or procedural styles.

It is commonly used embedded into C applications,[9] for rapid prototyping, scripted applications, GUIs, and testing.[10] Tcl interpreters are available for many operating systems, allowing Tcl code to run on a wide variety of systems. Because Tcl is a very compact language, it is used on embedded systems platforms, both in its full form and in several other small-footprint versions.[11]

The popular combination of Tcl with the Tk extension is referred to as Tcl/Tk, and enables building a graphical user interface (GUI) natively in Tcl. Tcl/Tk is included in the standard Python installation in the form of Tkinter.


The Tcl programming language was created in the spring of 1988 by John Ousterhout while working at the University of California, Berkeley.[12][13] Originally "born out of frustration",[9] according to the author, with programmers devising their own languages intended to be embedded into applications, Tcl gained acceptance on its own. John Ousterhout was awarded the ACM Software System Award in 1997 for Tcl/Tk.[14]

The name originally comes from Tool Command Language, but is conventionally spelled "Tcl" rather than "TCL".[15]

Date Event
January 1990 Tcl announced beyond Berkeley (Winter USENIX).
June 1990 Expect announced (Summer USENIX).
January 1991 First announcement of Tk (Winter USENIX).
June 1993 First Tcl/Tk conference (Berkeley). [table] geometry manager (forerunner of [grid]), [incr Tcl], TclDP and Groupkit, announced there.
August 1997 Tcl 8.0 introduced a bytecode compiler.[16]
April 1999 Tcl 8.1 introduces full Unicode support[17] and advanced regular expressions.[18]
August 1999 Tcl 8.2 introduces Tcl Extension Architecture (TEA)[19]
August 2000 Tcl Core Team formed, moving Tcl to a more community-oriented development model.[1]
September 2002 Ninth Tcl/Tk conference (Vancouver). Announcement of starkit packaging system. Tcl 8.4.0 released.[20]
December 2007 Tcl 8.5 added new datatypes, a new extension repository, bignums,[21] lambdas.[22][23]
December 2012 Tcl 8.6 added built-in dynamic object system, TclOO, and stackless evaluation.[24]

Tcl conferences and workshops are held in both the United States and Europe.[25]


Tcl's features include


Safe-Tcl is a subset of Tcl that has restricted features so that Tcl scripts cannot harm their hosting machine or application.[28] File system access is limited and arbitrary system commands are prevented from execution. It uses a dual interpreter model with the untrusted interpreter running code in an untrusted script. It was designed by Nathaniel Borenstein and Marshall Rose to include active messages in e-mail. Safe-Tcl can be included in e-mail when the application/safe-tcl and multipart/enabled-mail are supported. The functionality of Safe-Tcl has since been incorporated as part of the standard Tcl/Tk releases.[29][30]

Syntax and fundamental semantics

The syntax and semantics are covered by the twelve rules of the dodecalogue[31] (alternative wording[32]).

A Tcl script consists of several command invocations. A command invocation is a list of words separated by whitespace and terminated by a newline or semicolon.

word0 word1 word2 ... wordN

The first word is the name of a command, which is not built into the language, but which is in the library. The following words are arguments. So we have:

commandName argument1 argument2 ... argumentN

An example, using the puts command to display a string on the host console, is:

puts "Hello, World!"

This sends the string "Hello, World!" to the 'stdout' device, with an appended newline character.

Variables and the results of other commands can be substituted inside strings too, such as in this example where we use set and expr (no assignment operator =) to store a calculation result in a variable, and puts (short for "put string") to print the result together with some explanatory text:

# expr evaluates text string as an expression
set sum [expr 1+2+3+4+5]
puts "The sum of the numbers 1..5 is $sum."
# with curly braces, variable substitution is delayed until call time (dynamic scoping)
set x 1
set sum [expr {$x + 2 + 3 + 4 + 5}]; # $x is not substituted, and the expression is preserved
puts "The sum of the numbers 1..5 is $sum."; # 1 is substituted for $x, and the expression is evaluated
# without curly braces, variable substitution occurs at the definition site (lexical scoping)
set x 2
set op *
set y 3
set res [expr $x$op$y]; # $x, $op, and $y are substituted, and the expression is evaluated
puts "2 * 3 is $res."; # 6 is substituted for $res

There is one basic construct (the command) and a set of simple substitution rules.

Formally, words are either written as-is, with double-quotes around them (allowing whitespace characters to be embedded), or with curly-brace characters around them, which suppresses all substitutions inside (except for backslash-newline elimination). In bare and double-quoted words, three types of substitution occur (once, in a single left-to-right scan through the word):

From Tcl 8.5 onwards, any word may be prefixed by “{*}” to cause that word to be split apart into its constituent sub-words for the purposes of building the command invocation (similar to the “,@” sequence of Lisp's quasiquote feature).

As a consequence of these rules, the result of any command may be used as an argument to any other command. Also, there is no operator or command for string concatenation, as the language concatenates directly. Note that, unlike in Unix command shells, Tcl does not reparse any string unless explicitly directed to do so, which makes interactive use more cumbersome, but scripted use more predictable (e.g. the presence of spaces in filenames does not cause difficulties).

The single equality sign (=) for example is not used at all, and the double equality sign (==) is the test for equality, and even then only in expression contexts such as the expr command or the first argument to if. (Both of those commands are just part of the standard library; they have no particularly special place in the library and can be replaced, if so desired.)

The majority of Tcl commands, especially in the standard library, are variadic, and the proc (the constructor for scripted command procedures) allows one to define default values for unspecified arguments and a catch-all argument to allow the code to process arbitrary numbers of arguments.

Tcl is not statically typed: each variable may contain integers, floats, strings, lists, command names, dictionaries, or any other value; values are reinterpreted (subject to syntactic constraints) as other types on demand. However, values are immutable and operations that appear to change them actually just return a new value instead.

Basic commands

The most important commands that refer to program execution and data operations are:

The usual execution control commands are:

Those above looping commands can be additionally controlled by the following commands:

Advanced commands


uplevel allows a command script to be executed in a scope other than the current innermost scope on the stack. Because the command script may itself call procedures that use the uplevel command, this has the net effect of transforming the call stack into a call tree.[33]

It was originally implemented to permit Tcl procedures to reimplement built-in commands (like for, if or while) and still have the ability to manipulate local variables. For example, the following Tcl script is a reimplementation of the for command (omitting exception handling):

proc for {initCmd testExpr advanceCmd bodyScript} {
    uplevel 1 $initCmd
    set testCmd [list expr $testExpr]
    while {[uplevel 1 $testCmd]} {
        uplevel 1 $bodyScript
        uplevel 1 $advanceCmd


upvar arranges for one or more local variables in the current procedure to refer to variables in an enclosing procedure call or to global variables. The upvar command simplifies the implementation of call-by-name procedure calling and also makes it easier to build new control constructs as Tcl procedures.[34]

A decr command that works like the built-in incr command except it subtracts the value from the variable instead of adding it:

proc decr {varName {decrement 1}} {
    upvar 1 $varName var
    incr var [expr {-$decrement}]


Tcl 8.6 added a built-in dynamic object system, TclOO, in 2012.[26] It includes features such as:

oo::class create fruit {
    method eat {} {
        puts "yummy!"
oo::class create banana {
    superclass fruit
    constructor {} {
        my variable peeled
        set peeled 0
    method peel {} {
        my variable peeled
        set peeled 1
        puts "skin now off"
    method edible? {} {
        my variable peeled
        return $peeled
    method eat {} {
        if {![my edible?]} {
            my peel
set b [banana new]
$b eat                prints "skin now off" and "yummy!"
fruit destroy
$b eat                error "unknown command"

Tcl did not have object oriented (OO) syntax until 2012,[26] so various extension packages emerged to enable object-oriented programming. They are wide spread in existing Tcl source code. Popular such extensions include:

TclOO was not only added to build a strong object oriented system, but also to enable extension packages to build object oriented abstractions using it as a foundation. After the release of TclOO incr Tcl was updated to use TclOO as its foundation.[24]

Interfacing with other languages

Tcl interfaces natively with the C language.[35] This is because it was originally written to be a framework for providing a syntactic front-end to commands written in C, and all commands in the language (including things that might otherwise be keywords, such as if or while) are implemented this way. Each command implementation function is passed an array of values that describe the (already substituted) arguments to the command, and is free to interpret those values as it sees fit.

Digital logic simulators often include a Tcl scripting interface for simulating Verilog, VHDL and SystemVerilog hardware languages.

Tools exist (e.g. SWIG, Ffidl) to automatically generate the necessary code to connect arbitrary C functions and the Tcl runtime, and Critcl does the reverse, allowing embedding of arbitrary C code inside a Tcl script and compiling it at runtime into a DLL.

See also: Tcl/Java

Module Files

Environment Modules are written in the Tcl (Tool Command Language) and are interpreted by the modulecmd program via the module[36] user interface.

Extension packages

The Tcl language has always allowed for extension packages, which provide additional functionality, such as a GUI, terminal-based application automation, database access, and so on. Commonly used extensions include:

The most popular Tcl extension is the Tk toolkit, which provides a graphical user interface library for a variety of operating systems. Each GUI consists of one or more frames. Each frame has a layout manager.
One of the other very popular Tcl extensions is Expect extension. The early close relationship of Expect with Tcl is largely responsible for the popularity of Tcl in prolific areas of use such as in Unix testing, where Expect was (and still is today) employed very successfully to automate telnet, ssh, and serial sessions to perform many repetitive tasks (i.e., scripting of formerly interactive-only applications). Tcl was the only way to run Expect, so Tcl became very popular in these areas of industry.
Tile/Ttk[38] is a styles and theming widget collection that can replace most of the widgets in Tk with variants that are truly platform native through calls to an operating system's API. Themes covered in this way are Windows XP, Windows Classic, Qt (that hooks into the X11 KDE environment libraries) and Aqua (Mac OS X). A theme can also be constructed without these calls using widget definitions supplemented with image pixmaps. Themes created this way include Classic Tk, Step, Alt/Revitalized, Plastik and Keramik. Under Tcl 8.4, this package is known as Tile, while in Tcl 8.5 it has been folded into the core distribution of Tk (as Ttk).
Tix, the Tk Interface eXtension, is a set of user interface components that expand the capabilities of Tcl/Tk and Python applications. It is an open source software package maintained by volunteers in the Tix Project Group and released under a BSD-style license.[39]
Itcl is an object system for Tcl, and is normally named as [incr Tcl] (that being the way to increment in Tcl, similar in fashion to the name C++).
Tcllib is a set of scripted packages for Tcl that can be used with no compilation steps.
Tklib is a collection of utility modules for Tk, and a companion to Tcllib.
The TclUDP[40] extension provides a simple library to support User Datagram Protocol (UDP) sockets in Tcl.
Tcl Database Connectivity (TDBC), part of Tcl 8.6, is a common database access interface for Tcl scripts. It currently supports drivers for accessing MySQL, ODBC, PostgreSQL and SQLite databases. More are planned for the future. Access to databases is also supported through database-specific extensions, of which there are many available.[41]

See also


  1. 1 2 "Tcl/Tk Core Development". Tcl Developer Xchange. Retrieved 2016-11-01.
  2. "Latest Release: Tcl/Tk 8.6.6 (Jul 27, 2016)". Tcl Developer Xchange. 2016-07-27. Retrieved 2016-07-27.
  3. "Tcl/Tk License Terms". Tcl Developer Xchange. Retrieved 2016-11-02.
  4. "Tcl Dev Kit - Compiler". ActiveState Docs. Retrieved 2016-11-02.
  5. Lerdorf, Rasmus (2007-04-26). "PHP on Hormones – history of PHP presentation by Rasmus Lerdorf given at the MySQL Conference in Santa Clara, California". The Conversations Network. Retrieved 2009-12-11.
  6. Windows PowerShell : PowerShell and WPF: WTF
  7. "Language". Tcl Developer Xchange. Retrieved 2016-11-02.
  8. Tcl Fundamentals, Chapter 1 in Practical Programming in Tcl and Tk, ISBN 0-13-038560-3
  9. 1 2 From the inside flap of Tcl and the Tk Toolkit, ISBN 0-201-63337-X
  10. "Uses for Tcl/Tk". Tcl Developer Xchange. Retrieved 2016-11-02.
  11. "Cisco IOS Scripting with TCL Configuration Guide". Cisco Support. Retrieved 2016-11-02.
  12. John Ousterhout. "History of Tcl". Personal pages. Stanford University. Retrieved 2011-08-09.
  13. "History of Tcl". Tcl Developer Xchange. Retrieved 2016-11-02.
  14. "John K Ousterhout - Award Winner". ACM Awards. Retrieved 2016-11-04.
  15. From the Tcler's Wiki Tcl vs. TCL
  16. "Tcl/Tk 8.0 Release Announcement". Tcl Developer Xchange. Retrieved 2014-07-01.
  17. "Tcl/Tk 8.1 Release Announcement". Tcl Developer Xchange. Retrieved 2014-07-01.
  18. 1 2 "New Regular Expression Features in Tcl 8.1". Tcl Developer Xchange. Retrieved 2016-11-02.
  19. "Tcl/Tk 8.2 Release Announcement". Tcl Developer Xchange. 1999-08-18. Retrieved 2014-07-01.
  20. "Tcl/Tk 8.4 Release Announcement". Tcl Developer Xchange. 2013-06-01. Retrieved 2014-07-01.
  21. "TIP #237: Arbitrary-Precision Integers for Tcl". Tcl Developer Xchange. Retrieved 2016-11-01.
  22. "TIP #194: TIP #194: Procedures as Values via apply". Tcl Developer Xchange. Retrieved 2016-11-01.
  23. "Tcl/Tk 8.5 Release Announcement". Tcl Developer Xchange. 2013-09-18. Retrieved 2014-07-01.
  24. 1 2 "Tcl/Tk 8.6 Release Announcement". Tcl Developer Xchange. 2013-09-20. Retrieved 2014-07-01.
  25. "Tcl/Tk Conferences". Tcl Developer Xchange. Retrieved 2016-11-01.
  26. 1 2 3 "TIP #257: Object Orientation for Tcl". Tcl Developer Xchange. Retrieved 2016-11-01.
  27. "Download Tcl/Tk Sources". Tcl Developer Xchange. Retrieved 2016-11-01.
  28. "Safe Tcl". Tcl Developer Xchange. Retrieved 2016-11-01.
  29. Brown, Lawrie (September 18–20, 1996). "Mobile Code Security". In Terry Bossomaier, Lucy Chubb. Proceedings, 2nd Joint Conference, AUUG '96 and Asia-Pacific WWW '96. Melbourne, Australia. p. 50. Retrieved 2011-03-22.
  30. Welch, Brent B.; Jones, Ken; Hobbs, Jeffrey (2003). Practical programming in Tcl and Tk. 1 (4th ed.). Prentice Hall PTR. p. 291. ISBN 0-13-038560-3.
  31. "Tcl manual page - Tcl Built-In Commands". Tcl Developer Xchange. Retrieved 2014-06-14.
  32. "Dodekalogue". Tcler's Wiki. Retrieved 2014-06-14.
  33. "uplevel manual page - Built-In Commands". Tcl Developer Xchange. Retrieved 2016-06-14.
  34. "upvar manual page - Built-In Commands". Tcl Developer Xchange. Retrieved 2016-06-14.
  35. "Tcl C API". Retrieved 2016-11-02.
  36. "module - command interface to the Modules package". SourceForge. man page. July 2009. Retrieved 9 February 2014.
  37. "modulefile - files containing Tcl code for the Modules package". SourceForge. man page. July 2009. Retrieved 9 February 2014.
  38. "Tile: an improved themeing engine for Tk". SourceForge. Retrieved August 7, 2016.
  39. "Tix License". SourceForge. Retrieved August 7, 2012.
  40. "TclUDP". Tcl'ers Wiki. Retrieved August 7, 2012.
  41. "TDBC". Tcl'ers Wiki. Retrieved August 7, 2012.

Further reading

Wikibooks has a book on the topic of: Tcl Programming
Wikimedia Commons has media related to Tcl programming language family.
This article is issued from Wikipedia - version of the 11/25/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.