arcan VS docopt

Something like this ? https://arcan-fe.com/

This requires to remove the terminal emulator plus adjust IPC, like what arcan is doing: https://github.com/letoram/arcan

kragen, what's the current status of BubbleOS?

Also, I'm curious what you think of Arcan (https://arcan-fe.com)

afair ChromeOS do implement it, harder to find the commit but also know Arcan mentioned elsewhere in this thread added it quite a while ago https://github.com/letoram/arcan/commit/d547c55565a848946422e24eee324c8ed091ff15

I managed to find this one in my history: Arcan it does has a cool name ngl, I never tried it though

Lol not arcan

See https://arcan-fe.com/, in particular Lash: https://arcan-fe.com/2022/10/15/whipping-up-a-new-shell-lash...

LOL. Not. Meanwhile, one dude managed to write an entire display server that handles, both, Wayland and X11 apps: https://arcan-fe.com/

Arcan is a decent contender for an actual way forward (and like PipeWire replacing PulseAudio, Arcan natively supports X11 and Wayland clients)

Symfony Console closely follows the well-established docopt conventions. Docopt, based on longstanding conventions from help messages and man pages, ensures a consistent and intuitive interface for describing a program's interface. Symfony Console's adherence to docopt conventions guarantees that your command line tools maintain a standardized and predictable user experience, simplifying development and user interaction.

You probably already know, but just in case you don't, you might read about http://docopt.org/ It seems to me a lot of your usage ideas could be refinements of / tooling around docopt-style interfaces.

http://docopt.org/

Not quite what you asked for, but close: type example invocations to generate the CLI, and just pull the arguments from a dictionary at runtime.

I've been using docopt to handle CLI arguments for years now.

http://docopt.org/

If you aren't averse to using a third party package, on my personal projects I always found https://github.com/docopt/docopt to be nice.

You can kill 2 birds with one stone by documenting your scripts while also providing the argument structure / parsing.

As for the implementation differences, complgen uses a trivial DSL that’s everybody is already familiar with more or less because it’s a slightly more rigorous version of what tools usually spit out when you do command --help (projects like docopt even use that for command line arguments parsing). Those happen to be regular languages and therefore can be represented as a Deterministic Finite Automata. complgen compiles the grammars to DFAs, minimizes the DFA and spits out shell-specific shell completions scripts that simply walk the DFA to match and complete the current input.

The current completion system has a list of rules of which completions to use at which time. It's purposely simple to make it as flexible as possible. The current things I'm planning is a derive macro like what clap has to generate these rules. I'm also considering introducing a plugin that let's you write rules in the format of docopt

For anyone unfamiliar, docopt is an established standard for specifying arguments in a script’s doc string. I use it for Python and it’s lovely. You’re going to write a docstring with examples anyway, why not make them functional?

http://docopt.org/

I like http://docopt.org/ a lot. You seem like someone who might have opinions on that.