rad

Big fan of gron[0] and zoxide[1]. Gron for flattening and viewing JSON, and zoxide (z) for fuzzily jumping around on my system or on remote systems with z installed. Also been using Rad [2] (disclaimer: am author) to replace my suite of Bash scripts and write new ones, quite happy with one atm which sets reminders e.g. 'remind 2h check the CI build' which will give me an OS reminder in two hours, I use it a ton at work. [0] https://github.com/tomnomnom/gron [1] https://github.com/ajeetdsouza/zoxide [2] https://github.com/amterp/rad

I'm working on two main projects at the moment. One is Rad [0], a programming language tailored for writing CLI scripts and tools (mainly an alternative to Bash), taking a declarative approach to things like script arguments. Latest push has been largely on static type analysis, since making that really good is the sort of thing that helps both people and AI agents write good Rad. Second project is Kan [2], a Kanban board which operates on text files on your machine, and is designed to be Git friendly so you can check it into your repo. [1] https://github.com/amterp/rad https://amterp.dev/rad [2] https://github.com/amterp/kan https://amterp.dev/kan

I am continuing to work on Kan [0], a dev-focused kanban board that works via plain text files in your repository. I am finding it really useful for solo projects, giving a really simple way to get per-project Kanban boards that I can sync via Git. Since it's local only, it's really snappy, and given the dev-focus, it can offer some pretty nice workflows with local hooks, customization, etc. The other project I am continuing to work on is Rad [1], a programming language tailor made for writing CLI scripts. It's not for enterprise software, it specializes specifically in CLI, offering all the essentials built-in, such as a declarative approach to arguments and generated help (as opposed to Bash where you have to roll your own arg parsing and help strings each time). [0] https://github.com/amterp/kan [1] https://github.com/amterp/rad

This is exactly the frustration that lead me to write Rad [0] (the README leads with an example). I've been working on it for over a year and the goal is basically to offer a programming language specifically for writing CLIs. It aims for declarative args (no Bash ops parsing each time), automatic --help generation, friendly (Python-like) syntax, and it's perfect for dev build scripts. I'll typically have something like this: #!/usr/bin/env rad --- Dev automation script. --- args: build b bool # Build the project test t bool # Run tests lint l bool # Run linter run r bool # Start dev server release R bool # Release mode filter f str? # Test filter pattern filter requires test if build: mode = release ? "--release" : ""

I am working on Rad [0], a programming language built specifically for CLI scripts, so you don't need to write Bash, and it offers CLI-tailored features which make it a better choice than Python. Lately I've mainly been working on stability and bug fixes. I've released some big features the past few months so I'm doing a big push on polish, before I again tackle some larger features that I'd like to implement. If CLI scripts is something you're interested in at all, give it a go! We have docs and a guide [1] for getting started, feedback very welcome :) [0] https://github.com/amterp/rad [1] https://amterp.github.io/rad/guide/getting-started/

Love this, lots of great ideas I'll be stealing :) Folks interested in scripting like this might like this tool I'm working on https://github.com/amterp/rad Rad is built specifically for writing CLI scripts and is perfect for these sorts of small to medium scripts, takes a declarative approach to script arguments, and has first-class shell command integration. I basically don't write scripts in anything else anymore.

Working hard on Rad, which is aiming to be a Bash-replacement for writing CLI scripts. The goal is to allow users to write maintainable scripts with declarative argument parsing, built-in JSON processing, HTTP requests, and interactive prompts - all in a familiar, readable syntax (Python-like!). Here's an example of the declarative approach to script args: args: username str # Required string password str? # Optional string token str? # Optional auth token age int # Required integer status str # Required string username requires password // If username is provided, password must also be provided token excludes password // Token and password cannot be used together age range [18, 99] // Inclusive range from

Work continues for me on Rad[0]. It's a programming language designed specifically for CLI scripts. I was sick of writing Bash scripts and thought we could do much, much better, so that's the goal with this project. Been working on it for a bit over a year now, and I'm using it every day! Still have many big features in mind, such as commands, I suspect I'm still only at the beginning at this journey! [0] https://github.com/amterp/rad

Very much agree with the article, this is one of the reasons why I wrote Rad [0], which people here might find interesting. The idea is you write CLI scripts with a declarative approach to script arguments, including all the constraints on them, including relational ones. So you don't write your own CLI validation - you declare the shape that args should take, let Rad check user input for you, and you can focus your script on the interesting stuff. For example args: username str # Required string password str? # Optional string token str? # Optional auth token age int # Required integer status str # Required string username requires password // If username is provided, password must also be provided token excludes password /

Modern cmd line scripting is an interesting area and I like seeing people's different approaches to improving it. Personally, I want to get as far away from writing control flow, loops, etc in Bash as I can. I'm working on https://github.com/amterp/rad which is a CLI scripting language that takes a more Python-like approach, which people here might find interesting, though it serves slightly different cases than Modernish.

Been working on https://github.com/amterp/rad for almost a year now. It's a programming language designed for writing good CLI scripts, so it's aiming to replace Bash but is much more Python-like, and offers unique syntax and a bunch of in-built support for scripting. Please check it out if it sounds at all interesting! Keen for feedback :) I've written some docs, including a "getting started" guide, linked in the GitHub page.

I'm working on a programming language aiming to replace Bash. It specifically targets CLI scripts where Python or Rust are overkill, but it contains a bunch of constructs that make it particularly well suited for CLI scripts, including arg parsing, table formatting, HTTP querying, Bash command invocation, etc. Keen to hear people's thoughts and feedback! GitHub here: https://github.com/amterp/rad The docs site also contains a guide for getting started, including some of the unique features: https://amterp.github.io/rad/guide/getting-started/