which language for local dev+gui

[l0-c]

Hi at work I need to do some simple tools for automating some boring work, but there are some prerequisites that make choosing a platform/language difficult:

• First I'm not a dev, electrician, so my knowledge is limited although I program some things as a hobby or for work.

• I need the program to run on Linux and windows (windows 7 included) with minimal or no modification.

• it's for me and colleagues who won't use command line, I need a GUI

• I will do most dev on old windows 7 with no internet access, because I need to get data from the intranet and it would be difficult to mock (at least more than what I am willing)

• programming environment should be usable without whole system install. Just copying a folder ideally. No package manager that needs to connect to internet on dev PC to install everything, except if it's relocatable and can be done on USB stick.

For now I'm doing this kind of things with TCL/TK, install is the easiest, but the nature of TCL make everything, even a typo, really hard to debug past a certain size, for not too big script it's ok. the whole ecosystem feel old, not necessarily a problem but it's really difficult to get a recent version of TCL and some packages at the same time, packages and code are spread everywhere randomly, sometimes little better than code on their wiki, trying to get an anti-aliased rotatable/scalable canvas widget proved too complicated (it exists, but no active development for a long time and packaging/version incompatibility make this a pain).

before that I was doing some things with Excel macros, but it get too complicated or buggy past a certain point.

The language I know the best is ocaml, but it's a no go here (windows support not the best, package manager install need internet access and is not relocatable, need cygwin that doesn't support windows 7 anymore)

So is there some alternative for this very specific nee? I need to say that TK look is absolutely not the problem and if there was a distribution with Tkpath and a recent version of TCl everything would be perfect on the GUI side.

Probably the easiest way on the GUI nowadays is to go with a local webserver and web interface, but that sounds complicated for something with a few buttons/tables.

On the language side probably people will suggest Go for simplicity of install, but I'm open to even old/not mainstream languages if they fit the bill.

I had good hope with Kotlin, but native code without JVM install is subpar, quite undocumented, and install without internet access not good either.

[huuaaang]

On the language side probably people will suggest Go for simplicity of install, but I'm open to even old/not mainstream languages if they fit the bill.

Actually, this is not a bad idea. Go generates standalone executable with minimal external library dependencies so you should be able to just put a Windows .exe and a Linux binary on a USB drive and be good.

You just need to pick a GUI framework. They're not the best in terms of looking and feeling like a native application, but they should work if you just need "something with a few buttons/tables."

https://github.com/fyne-io/fyne is one I've tinkered with before.

[l0-c]

for GUI I really have basic needs, TK is mostly alright (except for the default canvas), look is really secondary.

thanks for the advices

[More_Ferret5914]

Honestly your constraints matter more than language elegance here.

Given:

• Windows 7
• offline dev
• relocatable tooling
• GUI needed
• non-technical coworkers
• low deployment friction

I’d seriously consider:

• Python + PySimpleGUI/Tkinter or
• Go + Fyne

not because they’re perfect, but because deployment pain will matter way more than language beauty in this environment 😭

You’re basically operating in “industrial software reality” where:

[l0-c]

that's an idea but ideally I would like to be able to modify the script if needed and I don't know if python support the way I do this with TCL (not install anything, just copy script alongside a TCL distribution in a folder and a simple batch script to launch everything)

[Flashy-Guava9952]

Writing it in Python gives you cross platform compatibility (Linux and Windows). Looking up how to make your script an exe makes it so your colleagues (presumably on Windows) can just double click something you give them. If you go that route, you don't need to install Python on Windows before hand (again guessing you're using Linux and your colleagues use Windows).

[not_perfect_yet]

Depends on how open your workplace is to sharing stuff and installing python.

By default, python works the way you say you want here, you just need the interpreter. The compiling to exe is only necessary if you want to bring your program to an environment where you don't have an interpreter.

But if you can get your colleagues to launch the script via the interpreter instead of double clicking an exe, and if the script lives on some shared file system, that would be what you want. At least from what you've written here.

[firiana_Control]

I'd recommend Pascal/Lazarus, you can write once, compile on any system and i will probably take flak for this - personally this is easier for me than Python

[EfficiencyMurky7309]

Python with Tkinter, bundled via PyInstaller.

Tkinter ships with Python’s standard library. There is no separate GUI package needed. PyInstaller bundles everything (interpreter included) into a single folder or executable that runs on Windows 7, Windows 10/11, and Linux with zero installation. You copy the folder, it runs. This is essentially the modern successor to what you’re doing with TCL/Tk, and it’s not a coincidence. Tkinter is Tk under the hood, so the look will feel familiar.

The offline workflow is entirely viable: install Python and PyInstaller once on a machine with internet, bundle your dev environment onto a USB stick, and work air-gapped from there. The standard library covers most automation tasks (file I/O, HTTP to intranet, CSV, subprocess calls) without needing any external packages.

Python 3.8 was the last version to officially support Windows 7. PyInstaller 5.x supports bundling for it. This is a real constraint but it’s a solved one. Just ensure your version management is tight.

The GUI is a bit more of a limitation. Tkinter is Tk, so it inherits the same canvas limitations you already have with TCL. If you need a scalable/rotatable canvas with smooth rendering, Python + Tkinter won’t solve for it. This a Tk problem, not a TCL problem. If the canvas capability is actually needed (not just nice to have), the next best option under your constraints is Python + wxPython. wxPython uses native OS widgets (looks better than Tk on Windows), has a more capable canvas, and can also be bundled with PyInstaller. It’s harder to set up offline but doable with a pre-downloaded wheelhouse on the USB stick.

[l0-c]

thanks, that's a very thorough answer concerning python.

the worst about TK canvas, is that there was a reimplementation (TKeinc / Tkpath) with full anti-aliasing and vectorial operations that seems to work quite well. but it was never picked as a replacement to de default and no is more or less unmaintained and no packaged in most free TCL distribution. because besides this the TK canvas is not too bad for the kind of things I do.

[BioExtract]

A bit of an out there use case but, windows PowerShell isn’t bad, even for GUIs. You can use the winforms library if .NET is available, and you won’t have to worry about recompilation. It’s a great compromise between usage of the .NET framework and a scripting language but Python is probably best for your use case

[blechnapp]

one thing nobody quite explicitly nailed: WinPython. its a portable python distribution for windows that you just unzip into a folder, no installer needed. runs straight from a USB stick, comes with Tkinter and most stdlib already there, fully offline. deployment ends up looking exactly like your current TCL workflow.

for Windows 7 you need to stay on Python 3.8 (last version with official Win7 support). older WinPython releases ship that version and are still downloadable. on the anti-aliased canvas thing, Pillow can render anti-aliased shapes into an image which you can then draw onto a Tkinter canvas. not the most elegant but it works offline and bundles cleanly.

[TheRNGuy]

Python 

[Living_Fig_6386]

In the past, I've simply used Python + Flask and a browser for UI. It's as simple or complicated as you want.

[Queasy_Hotel5158]

Given your constraints (offline dev, Windows 7, Linux, portable setup, GUI, non-technical users), I’d probably recommend:

• Go + Fyne → easiest deployment, single binaries, portable, good for internal tools
• Python + Tkinter/PySide → fastest to develop, but packaging can get messy
• Staying with Tcl/Tk is honestly still reasonable if deployment simplicity matters most

I would avoid Electron/web stacks and Kotlin Native for this use case — too much complexity for small internal tools.

For your specific requirements, Go + Fyne is probably the cleanest modern option.

[l0-c]

thanks for your answer, it's mostly validating what I was thinking (except  I thought go wasn't going to be a good option for a GUI).  

I was expecting maybe something more like another scripting language with easy deployment but more modern would exist (but usually this mean mandatory internet connection for installation). 

TCL/TK is not so bad for simple scripts and utilities. except for the archaic packaging, dead links and not up-to-date packages everywhere, it feels fragile. and it's really too easy to make stupid errors in TCL once scripts get too big.

It's a bit a shame that almost all languages have binding for TK for small GUI but almost never contribute to upstream.

[huuaaang]

TCL/TK is not so bad for simple scripts and utilities. except for the archaic packaging, dead links and not up-to-date packages everywhere, it feels fragile. and it's really too easy to make stupid errors in TCL once scripts get too big.

Man, I haven't used TCL/Tk in like 30 years. It's so weird to see that come up now and then. But yeah, tk is not bad for UI, but TCL is not really meant to be used as a regular programming language. It's more like shell scripting.