Guys, can you point some good examples, please, on how to implement (preferably in Kotlin) interactive command-line mode for an app, just like smbclient has?

This would be mostly the same as how youd do it in Java, so that's a good starting point. Unless you use native which should probably be specified.

Yep, just looking through Java Curses library. But I hope it can be done in more simple way, perhaps,

java.io.Console

If you are heading down the curses library route then Kotlin Native is the way to go. Will have much more control, and the developed program will be using less resources than a Kotlin JVM one.

I would like to target JVM for more portability, so end-user can launch it on Mac/Win/Linux without compiling

One of the major issues with JVM based programs is that they are difficult to deploy compared to native ones (eg have to include the JVM runtime, and figure out a way to create a binary).

Agree, especially with JavaFX 🙂

Which library?

I'm still on JDK8

Agree, especially with JavaFX

Good luck with distributing native application with UI for different platforms

Swing causes less troubles than JFX (don't need to install a separate library as in case of OpenJFX)

Yes, I agree that now run Fx apps is less pleasant, but you can just bundle JavaFx module

Gtk and Qt are claiming to be cross-platform, but... I tried once Qt on Windows - do not want anymore. From ordinary user's view installing JVM is a pain (installing JVM + JavaFX is a nightmare). Support native graphical toolkits (VCL, Cocoa, Gtk, Qt, Tk, etc) is a nightmare for developers. Command-line interface should work in most cases 🙂

installing JVM + JavaFX is a nightmare

JavaFx module jus should be bundled to your app, so you can run it on JVM without Fx

You can also try targeting Kotlin/JS and use some Node.js libraries (https://github.com/chjj/blessed). It should be relatively easy to deploy using npm.

Interesting option (bookmarked it)

Gtk wasn't meant to be used on platforms other than Linux even though Gtk is cross-platform. On Linux Gtk is native since most of the desktop environments (Cinnamon, Gnome, Xfce etc) are Gtk based.

@napperley, have you tried to use Kotlin native + Qt? Just interesting for comparison difficulty/portability

Qt is C++ framework (some even arguing that it’s C++ at all, but some Cpp-like language) with a lot of own complications

Discussion slowly slithered to cross-platform graphics... In my view the most optimal solution is CLI that depends solely on basic JVM (without JavaFX), so that it can be used even on servers without graphics available. So far I have found only 2 options: text-io libraries and jline3 libraries. Also suggestions to use native + some (what) libraries for command-line and JS/Blessed with NPM (perhaps, Electron)

How requirement “it can be used even on servers without graphics” and Electron are coexist?

@gildor, you're right, text-io seems to be quite primitive with some unnessesary features. As for Electron... I thought about an alternative when terminal emulator is not available. For JVM such an alternative can be Swing window, for JS, I guess, Electron 🙂

alternative when terminal emulator is not available

And when it’s not available?

When a program is launched via link or some other GUI

Electron is huge, don’t think that it make any sense to use it for small/medium application, it’s perfect if you already have some code on web

In my view NPM is not preferable either

When a program is launched via link

But there is no universal way to do that, you need some integration with operation system for this

some other GUI

What kind UI? I also don’t think that there is any OS-independent solution

Lanterna looks awesome, thanks for the link

Kotlin Native doesn't have C++ interop so QT isn't a option.

Bad news 😞

not sure that if you have no way to use QT is may consider as bad news :troll:

Problems with C++ interop are bad. Actually I was dreaming to capture the (software) world with Kotlin

Direct interop with C++ is a c huuuge pain, C++ doesn't have stable ABI, very few languages actually invest into it (for example D, which was originally target C++ interop and positioned as C++ replacement), Even languages as Rust don't have it. So essentially the only way is expose C++ API using C

Hmm. That I was thinking about... E.g. we have OpenCV library that is written in C++, it also has Java interface. But in C++ it's possible to overload operators, i.e. we can

rectA + rectB

or

captureDevice >> frameToProcess

, but with Java it would be just

rectA.add(rectB)

or

captureDevice.read(frameToProcess)

. I was thinking that it would be nice to have C++ interop because of operator overloading in both C++ and Kotlin

OpenCV has official C and Java APIs so possible to use from Kotlin Native and JS. Not sure about OpenCV, but operator overload is least problem when you use API of another language (especially such complicated as C++)