Tcl Tutorial
  • tcl-tk - Tutorial
  • - Css
  • - W3css
  • tcl-tk - Useful Resources
  • Tcl-tk - Ebook Download

  • Tcl

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

    It is commonly used embedded into C applications, for rapid prototyping, scripted applications, GUIs, and testing. 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.

    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. Originally "born out of frustration", according to the author, with programmers devising their own languages intended to be embedded into applications, Tcl gained acceptance on its own. Ousterhout was awarded the ACM Software System Award in 1997 for Tcl/Tk.

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

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


    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. 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.

    Syntax and fundamental semantics

    The syntax and semantics of Tcl are covered by twelve rules known as the Dodekalogue.

    A Tcl script consists of a series of 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 may be built into the language or found in an available library or defined in the script itself; the subsequent words serve as arguments to the command:

    commandName argument1 argument2 ... argumentN

    The following example uses the puts command to display a string of text on the host console:

    puts "Hello, World!"

    This sends the string "Hello, World!" to the standard output device along with an appended newline character.

    Variables and the results of other commands can be substituted into strings, such as in this example which uses the set and expr commands to store the result of a calculation in a variable note that Tcl does not use = as an assignment operator, and then uses 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."

    The # character introduces a comment. Comments can appear anywhere the interpreter is expecting a command name.

    # with curly braces, variable substitution is performed by expr
    set x 1
    set sum [expr {$x + 2 + 3 + 4 + 5}]; # $x is not substituted before passing the parameter to expr;
                                         # expr substitutes 1 for $x while evaluating the expression
    puts "The sum of the numbers 1..5 is $sum."; # sum is 15
    # 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

    As seen in these examples, there is one basic construct in the language: the command. Quoting mechanisms and substitution rules determine how the arguments to each command are processed.

    One special substitution occurs before the parsing of any commands or arguments. If the final character on a line i.e., immediately before a newline is a backslash, then the backslash-newline combination and any spaces or tabs immediately following the newline are replaced by a single space. This provides a line continuation mechanism, whereby long lines in the source code can be wrapped to the next line for the convenience of readers.

    Continuing with normal argument processing, a word that begins with a double-quote character " extends to the next double-quote character. Such a word can thus contain whitespace and semicolons without those characters being interpreted as having any special meaning i.e., they are treated as normal text characters. A word that begins with an opening curly-brace character { extends to the next closing curly-brace character }. Inside curly braces all forms of substitution are suppressed except the previously mentioned backslash-newline elimination. Words not enclosed in either construct are known as bare words.

    In bare and double-quoted words, three types of substitution may occur:

    Substitution proceeds left-to-right in a single scan through each word. Any substituted text will not be scanned again for possible further substitutions. However, any number of substitutions can appear in a single word.

    From Tcl 8.5 onwards, any word may be prefixed by {*}, which causes the 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 = serves no special role in the language at all. The double equality sign == is the test for equality which is used in expression contexts such as the expr command and in the first argument to if. Both commands are part of the standard library; they have no special place in the library and can be replaced if 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.

    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:

    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.

    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.

    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. 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, so various extension packages emerged to enable object-oriented programming. They are widespread in existing Tcl source code. Popular 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.

    Web application development

    Tcl Web Server is a pure-Tcl implementation of an HTTP protocol server. It runs as a script on top of a vanilla Tcl interpreter.

    Apache Rivet is an open source programming system for Apache HTTP Server that allows developers to use Tcl as a scripting language for creating dynamic web applications. Rivet is similar to PHP, ASP, and JSP. Rivet was primarily developed by Damon Courtney, David Welton, Massimo Manghi, Harald Oehlmann and Karl Lehenbauer. Rivet can use any of the thousands of publicly available Tcl packages that offer countless features such as database interaction Oracle, PostgreSQL, MySQL, SQLite, etc., or interfaces to popular applications such as the GD Graphics Library.

    Interfacing with other languages

    Tcl interfaces natively with the C language. 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.

    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: