Develop Cross-Platform CLI and GUI Tools with Tcl/Tk

I use Tk routinely in Scheme; there is no Tcl in my code, but Tk is a very nice (though basic) GUI kit, and my programs work on Linux, BSD, MacOS, and Windows. Other commenters have mentioned that Python ships with Tkinter, a library module that interfaces to Tk. I believe Ruby does the same. Hell, if you're programming in Cobol, you can have Tk (as long as your Cobol allows you to call C). You do not have to love Tcl to love Tcl/Tk.

> Those GUI apps look native on Windows, Linux and macOS

I don’t see how the author can write this with a straight face.

The apps look like what native apps looked like in 2003.

I was an early adopter of the TiVo. You can hook up a terminal to those things. A dumb terminal or terminal software on your computer using your own serial port. There was a terminal/serial port in the back (baud 2600)that took the form of a 3/4" audio plug.

It was a Linux system, but all their own software running on it was written in TCL.

I don't think they were using TK though.

Pretty fun to hack around with. Since it was connected to the phone line, when a call came in it could get the caller ID off the line and display it on the TV screen.

Still find Tcl/Tk surprisingly effective for simple cross-platform GUI utilities. The `wish` shell was my go-to for quick internal tools.

Tkinter or other Tk based GUI interfaces are the immediate tool I reach for whenever I build something that's not in the CLI or in the browser.

My general "daily driver" is python and I love that I can just spin up a cross-platform tool immediately with it. Tcl/Tk rule and are insanely useful.

It made me remember, me learning programing and building random GUIS app in tkinter and python.

Some of these UIs look simpler and better / more user friendly to me than the latest offerings from Apple and Microsoft. Especially this: https://cgicoffee.com/blog/content/images/2026/tcl-tk-articl... Looks like OpenBox?

Worked on a NASA ground control system written in Tk. It was a great way to learn about classic design pattern because we had to roll our own event reactors, observers, plugins.

Honestly it feels very outdated compared to the reactive type of GUI's we have today.

Maybe there are some nice wrappers now that help...

I'd give a Rust based version a try. Just compile into a binary for your platform and off you go.

I take issue with the only 100 MB footprint, that is still pretty big when consider fasm, tcc and rebol are all closer to 1 meg.

I built a Tcl/TK GUI in 1997 and I thought that it (specifically Tcl) was dated then. If you're used to anything beyond shell scripting, Tcl feels very un-programming. It does look they added objects in 2012, I can't speak to that.

Notwithstanding anything about LLM tools being able to do GUIs any way you want in 2026, I'd really consider just about anything else at this point. JavaFX, React Native, Electron, Flutter, etc.

the problem with Tcl/Tk is Tcl. the author does write about the quirks and problems, so this is a good article, but the end of it is that Tcl is simply not a language that i am interested in mastering. just like shell scripting. i'll use it if i have to, but it is not my preference.

and as the article also mentions what makes the apps cross platform is the native or near-native GUI. and apparently Tk is good for that.

but i'd rather use a nicer language with it. again, the article does talk about python, and points out that the Tk bindings in python are simply not good enough. that was very insightful, and i am glad to know.

however i would like to know if any other languages do better here. what about go for example? has anyone tried Tk with other languages and can share some experience?

Fun fact: macOS hex editor "Hex Fiend" uses Tcl for its templating language:

https://github.com/HexFiend/HexFiend/tree/master/templates

I appreciate this reminder that boring old tech is pretty fucking good tech; especially to your non-ReactJS-not-anti-ReactJS dev, here.

The comments are also a helpful reminder of the various sw and visual design/GUI values folks hold.

I personally never gotten past exploring Tkinter but like everything else I played with until I found reason to depend on it, that'll probably change since it's as available as vim and python and _that's_ the kind of thing I value. Limitations/constrains are the engineer's problem, not the tool's (unless they are the tool's problem (but even then, just be your natural creative self and roll with it))

On Linux there is also this windowing shell `wish` which I've used for some very quick (and very very dirty) UIs

> Alas, the complexity of its meta-object compiler (MOC)

Do these people use the same template when writing about GUIs? I mean what's complicated about MOC? In CMake it's even transparent and the user doesn't even see it. I swear, the same argument coming back year after year. "MOC" is complicated, but the compiler itself and ld isn't?

[flagged]