Tcl facts for kids

For the Chinese electronics company, see TCL Technology. For other uses, see Tcl (disambiguation).

Quick facts for kids
Tcl
Major implementations

Paradigm	Multi-paradigm: event-driven, functional, imperative, object-oriented
Designed by	John Ousterhout
Developer	Tcl Core Team
First appeared	1988; 37 years ago (1988)

Stable release	9.0.2 / 2 July 2025; 51 days ago (2 July 2025)

Typing discipline	Dynamic typing, everything is a string
Implementation language	C, Tcl
License	BSD-style
Filename extensions	.tcl, .tbc
Website
ActiveTcl Androwish
Dialects
Jim, Eagle
Influenced by
AWK, Lisp
Influenced
PHP, PowerShell, Tea, TH1

Tcl (pronounced "tickle") is a special kind of programming language. It's like a set of instructions you give to a computer. Tcl stands for "Tool Command Language."

It was made to be simple but very powerful. In Tcl, almost everything you do is treated as a "command." This includes telling the computer to remember a value or to create a new instruction.

Tcl can be used in many ways. For example, it can help you build graphical user interfaces (GUIs), which are the visual parts of software you click on. It's also good for quickly making test versions of programs.

You can use Tcl on many different operating systems, like Windows, macOS, and Linux. Because it's a small language, it can even be used in tiny computer systems called embedded systems.

When Tcl is combined with something called Tk, it's known as Tcl/Tk. Tk helps you build those GUIs easily. You might have even used Tk without knowing it, as it's part of the standard Python installation.

History of Tcl
- Key Moments in Tcl's Development
What Tcl Can Do
- Safe-Tcl for Security
How Tcl Code Works
Important Tcl Commands
Tcl for Web Applications
Connecting Tcl with Other Languages
Tcl Extension Packages
See also

History of Tcl

Tcl was created in 1988 by a person named John Ousterhout. He was working at the University of California, Berkeley.

John Ousterhout made Tcl because he was frustrated. Programmers often made their own small languages to add features to software. He wanted a simpler, more standard way to do this.

Tcl was first used for designing computer chips. But soon, people realized it could be useful for many other things too. In 1997, John Ousterhout won an award for creating Tcl/Tk.

Key Moments in Tcl's Development

January 1990: Tcl was first introduced to a wider audience outside of Berkeley.
January 1991: The Tk part of Tcl/Tk was announced.
August 1997: Tcl version 8.0 came out. It made programs run faster by using something called a bytecode compiler.
April 1999: Tcl 8.1 added full support for Unicode. This means it could handle text from many different languages around the world.
August 2000: The Tcl Core Team was formed. This group helps guide how Tcl is developed by the community.
December 2007: Tcl 8.5 was released. It added new types of data and improved how numbers are handled.
December 2012: Tcl 8.6 introduced a new way to create objects directly within the language.
September 2024: Tcl 9.0 was released. It added support for 64-bit systems and even more Unicode characters.

Tcl has conferences and workshops in different countries. Many companies, like FlightAware, use Tcl in their products.

What Tcl Can Do

A Tcl file being edited in the Eclipse IDE

Tcl has many cool features that make it powerful and flexible:

Everything is a Command: In Tcl, all actions are commands. This makes the language very consistent and easy to learn.
Flexible Arguments: Commands can often take different numbers of inputs.
Change Anything: You can change or redefine almost anything in Tcl while the program is running.
Strings are Key: All types of data, even the program's own code, can be treated as strings (text). Tcl automatically changes data types when needed.
No Variable Declarations: You don't need to declare variables before using them. You just give them a value.
Object-Oriented: Tcl has a built-in system for object-oriented programming (TclOO). This helps organize code into reusable "objects."
Event-Driven: Tcl can react to events, like when a file is opened or data arrives over a network.
Works Everywhere: Tcl programs can run on many different computer systems, including Windows, Unix, Linux, and Mac.
GUI Integration: It works very well with the Tk library to create graphical user interfaces.
Easy to Extend: You can add new features to Tcl using other languages like C, C++, Java, or Python.
Interpreted Language: Tcl code is run by an interpreter, which translates it into computer instructions on the fly.
Unicode Support: It fully supports Unicode, so it can handle text from almost any language.
Regular Expressions: Tcl can use regular expressions to find and work with patterns in text.

Safe-Tcl for Security

Safe-Tcl is a special version of Tcl that has limited features. This makes sure that Tcl programs cannot harm the computer or application they are running on. For example, it can limit access to files or prevent certain system commands from running. This was designed to make email safer by allowing small programs to be included without risk.

How Tcl Code Works

Tcl code is made up of a series of commands. Each command is a list of words separated by spaces. A command usually ends with a new line or a semicolon. The first word is the command's name, and the words after it are its inputs.

commandName input1 input2 ... inputN

For example, the puts command (short for "put string") shows text on your computer screen:

puts "Hello, World!"

This command displays "Hello, World!" and then moves to a new line.

You can also use variables and the results of other commands inside your strings. Look at this example:

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

Here, `set` stores the result of `expr 1+2+3+4+5` (which is 15) into a variable called `sum`. Then, `puts` displays a message that includes the value of `sum`.

The `#` symbol means the rest of the line is a comment. Comments are notes for people reading the code and are ignored by the computer.

# 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 to 6
puts "$x $op $y is $res."; # $x, $op, $y, and $res are substituted and evaluated as strings

Tcl has special rules for how it reads your code:

Double Quotes (") let you include spaces and semicolons in a word without them being seen as special.
Curly Braces ({}) stop Tcl from changing variables or running commands inside them. This is useful when you want to treat something as plain text.
Square Brackets ([]) tell Tcl to run a command inside the brackets and use its result. For example, `[expr 1+2]` will run the `expr` command and replace itself with `3`.
Dollar Sign ($) is used to get the value of a variable. So, `$foo` means "the value stored in the variable named foo."
Backslash (\) is used for special characters, like `\n` for a new line.

Important Tcl Commands

Here are some of the most common commands you'll use in Tcl:

Basic Commands

`set`: This command is used to give a value to a variable. If you use it with only one input, it will show you the value of that variable.
`proc`: This command lets you create your own new commands, which are like mini-programs.
`if`: This command checks a condition. If the condition is true, it runs a specific block of code. You can also add `elseif` and `else` for other conditions.
`while`: This command keeps running a block of code over and over as long as a condition remains true.
`foreach`: This command runs a block of code for each item in a list.
`for`: This command is a shortcut for loops. It sets up a variable, checks a condition, and updates the variable after each run.
`break`: This command stops a loop immediately.
`continue`: This command skips the rest of the current loop and goes to the next round of the loop.
`return`: This command stops the current command or procedure and sends a value back to where it was called from.

Other Useful Commands

`expr`: This command calculates mathematical expressions.
`list`: This command creates a list of items.
`array`: This command helps you work with special variables called arrays, which store data in pairs.
`dict`: This command helps you work with dictionaries, which are like lists of key-value pairs.
`regexp`: This command checks if a text string matches a regular expression pattern.
`regsub`: This command replaces parts of a string based on a regular expression pattern.
`uplevel`: This command lets you run code in a different part of your program's structure.
`upvar`: This command creates a link to a variable in a different part of your program.
`namespace`: This command helps you organize your commands and variables into separate groups.
`try`: This command helps you handle errors that might happen in your code.
`catch`: This command also helps you catch and deal with errors.

Uplevel and Upvar

`uplevel` and `upvar` are advanced commands that help Tcl programs be very flexible.

`uplevel` lets a command run code as if it were in a different part of the program. This is useful for creating new control commands like `for` or `if`.
`upvar` lets a variable in one part of your code refer to a variable in another part. This is helpful for making commands that change variables directly.

Here's an example of `decr` (decrement) using `upvar`:

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

This `decr` command works like the built-in `incr` command, but it subtracts a value instead of adding it.

Object-Oriented Programming in Tcl

Object-oriented programming (OOP) is a way to organize code using "objects." These objects can contain both data and actions (methods). Tcl added a built-in OOP system called TclOO in 2012.

TclOO allows you to:

Create classes, which are like blueprints for objects.
Customize objects individually.
Use advanced features like "mixins" to combine features from different classes.

Here's a simple example of OOP in Tcl:

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
        }
        next
    }
}
set b [banana new]
$b eat               → prints "skin now off" and "yummy!"
fruit destroy
$b eat               → error "unknown command"

This code creates a `fruit` class and a `banana` class that inherits from `fruit`. It shows how a banana object can be "peeled" and then "eaten."

Before TclOO, many other extensions were used for OOP, like incr Tcl and XOTcl. Now, many of these extensions use TclOO as their base.

Tcl for Web Applications

Tcl can also be used to build websites and web applications:

Tcl Web Server: This is a web server written entirely in Tcl. It can run web pages and applications.
Apache Rivet: This is a system that lets you use Tcl as a scripting language for the Apache HTTP Server. It's similar to how PHP or JSP work, allowing you to create dynamic web pages. Rivet can connect to databases like MySQL and PostgreSQL.

Connecting Tcl with Other Languages

Tcl is very good at working with other programming languages, especially C. This is because Tcl was originally designed to be a way to control commands written in C.

Tools exist that can automatically connect C functions to Tcl. This means you can write parts of your program in C for speed and still control them with Tcl. You can even embed C code directly into a Tcl script and compile it while the program is running!

Tcl Extension Packages

Tcl has many "extension packages" that add more features. Here are some popular ones:

Tk: This is the most famous Tcl extension. It provides a library for creating graphical user interfaces (GUIs) that work on many different operating systems.
Expect: This extension is very popular for automating tasks on Unix systems. It can control programs that usually require a person to type commands, like logging into a server.
Tile/Ttk: This package helps make Tk GUIs look more like the native applications on different operating systems (like Windows or macOS).
Tix: This is another set of user interface components that add more widgets to Tcl/Tk applications.
Itcl/IncrTcl: This is an object-oriented system for Tcl, often called [incr Tcl].
Tcllib: This is a large collection of useful Tcl scripts that you can use without needing to compile anything.
Tklib: This is a companion to Tcllib, providing more utility modules specifically for Tk.
tDOM: This extension helps Tcl programs read and understand XML files.
TclTLS: This extension adds secure communication features to Tcl using OpenSSL.
Databases: Tcl Database Connectivity (TDBC) is a standard way for Tcl programs to connect to different databases like MySQL, PostgreSQL, and SQLite.