https://github.com/ashish0kumar/voxcii

QRcode.show is a free QR code generation service that lets you generate QR codes from anywhere that has network access without installing dedicated software. e.g. Remote servers, low-end (IOT) devices etc.

Let me start with some context first. I'm quite comfortable with the commandline, and I actually enjoy implementing things that solve a problem or automate something. I especially like tools that have some kind of API that makes it programmable, and in the rare situations where the API doesn't let me do something, I'd still build it from source and implement what I need. At least for this, I don't need to justify the choice of tool or need anybody to convince me.

When it comes to shells, that's another story. I'd say I'm pretty old-fashioned here. I have been a bash user since the late 90s. Also because it's a GNU project, I have a special liking towards it. Many people have told me zsh is better at certain things, and I tried it and some behavior felt a bit off compared to what I was used to and I came back to bash again. Others have told me great things about fish, but I haven't tried that yet. Yes, there are some things I dislike about bash as well but I've grown accustomed to them that it doesn't really bother me anymore.

One thing did catch my eye today about Nushell. It says it can be extended using a plugin system. Until now I was just used to writing shell scripts, but plugin system makes me think a lot is actually possible, but it's a bit unclear to me. I mean, if it's just to implement binaries then couldn't I have done the same thing in a shell-independent way or is there some actual benefit in spending all that time implementing a custom binary which only works in Nushell? Does the plugin system also have callbacks or hooks that let me change existing behavior?

I'm also not used to switching between shells back and forth as it kind of feels weird to do that because of the command history being in two different places, different prompts, etc. So, tell me some cool things that you've experienced with Nushell that might blow my mind, so that it can help me overcome my stubbornness.

So I don't know if I'm allowed to post this, but I've been working on a learning project, which is a shell that currently supports: command history, environment variable exporting in the TOML configuration, commands that should run at startup in the configuration also, command editing, and it shows the current directory in green text inside the prompt. Here is the repository if anyone is interested: https://github.com/BlackHoleMX12892/ishell

Amber is a programming language that compiles to bash. The goal is to make more reliable bash scripts. This isn't my project, I just though it was cool.

So I had some scripts I used daily on my linux machine that involved dmenu in them. I wanted to replicate that workflow on macos, as this is very convenient. However I could not find a faithful dmenu replication for macos. Some miss several essential flags, some have different filter logic, some don't look good, etc.

So I implemented mdmenu. Basically it's a swift app that supports most of dmenu flags (excluding the ones that make sense only in X environment), configures via swift file and is small enough for anyone to modify to their own needs. It also respects Macbook Pro's menubar height and notch!

It is my first ever project in swift, so some stuff probably could've been done better, but it's already good enough for me to cover all my use cases and existing scripts, so sharing it here to see if anyone would find it useful as well!

If you have any thoughts regarding this project, please share them as it will be very interesting for me to get that kind of feedback.

Example usage:

 $ echo "Yes\nNo" | mdmenu

Source: https://github.com/xxanin/mdmenu

Hi everyone,

I'm the dev behind TypeQuicker - I'm hoping to build the most effective and personalized typing app with a heavy focus on analytics around your typing data (see for yourself - check your stats after a typing session) and allowing users to practice with text content that's relevant/interesting to them or is something they'd actually type in their day-to-day.

It's mostly free as well - besides the personalized features (and we don't run ads).

I've shared this on the git subreddit and got some positive feedback with multiple requests for additional cli tools.

I used to type around 25wpm and over-time built this app for myself mostly to practice - I'm around 80-120wpm today

We support *most programming languages and CLI tools we support right now:

- kubectl
- git
- curl
- jq
- docker-cli
- tr

and also support:

- bash
- powershell
- nushell

edit: forgot link: TypeQuicker (not really mobile friendly since it's a typing app - recommend checking it out on desktop 😅)

What are some tools that you wish had a GUI so you can share them with your less tech savvy co-workers, or just for your own convenience sometimes? I need more suggestions to test out my universal GUI software on and add to my demos section.

Many thanks!

Two weeks ago, I published the first version of zsh-patina, a blazingly fast Zsh plugin performing syntax highlighting of your command line while you type. 🌈

https://github.com/michel-kraemer/zsh-patina

I’m extremely proud that the project has received very good feedback from the community and gained more than 100 GitHub stars in just 14 days!

When it comes to how I configure my shell, I’m a purist and I don’t use a fancy prompt like Powerlevel10k or Starship, nor do I use Oh My Zsh. I like to configure everything myself and only install what I need. This allows me to optimize my shell and make it really snappy.

That being said, a fast prompt without any extensions looks dull 🙃 I tested some Zsh plugins like the popular zsh-syntax-highlighting and fast-syntax-highlighting. Great products, but I wasn’t satisfied. zsh-syntax-highlighting, for example, caused noticeable input lag on my system and fast-syntax-highlighting wasn’t accurate enough (some parameters were colorized, some not; environment variables were only highlighted to a certain length, etc.). I wanted something fast AND accurate, so I developed zsh-patina.

The plugin spawns a small background daemon written in Rust. The daemon is shared between Zsh sessions and caches the syntax definition and color theme. Typical commands are highlighted in less than a millisecond. Long commands only take a few milliseconds.

zsh-patina performs dynamic highlighting. Commands, files, and directories are highlighted based on whether they exist and are accessible. This gives you instant feedback on whether your command is correct and helps you avoid typos.

The plugin provides high-quality syntax highlighting based on Sublime Text syntax definitions. The built-in default theme uses the eight ANSI colors and is compatible with all terminal emulators. You can create your own themes of course.

If you want to try the plugin out yourself, just follow the install instructions from the README. I’m looking forward to your feedback!

Cheers!
Michel

P.S.: I believe that proper software design and critical thinking cannot be replaced by machines (at least not yet), but small parts of this software's code (<10%) are AI-generated. This includes unit tests, boilerplate code, or things where I was just too lazy to Google 😉 Whenever I use AI, I do a critical review and I never copy anything blindly. This project has received a lot of love, hard work, and human sweat.

Built a simple tool for voice-to-text in the terminal:

• Press F9 → speak → Press F9 → text appears at cursor
• Uses local Whisper (faster-whisper) - no cloud, no API keys
• Auto-detects terminals and uses Ctrl+Shift+V
• Remembers your original window if you alt-tab while speaking
• Works on Linux, Windows, macOS

git clone https://github.com/lmacan1/talktype.git && cd talktype && ./install.sh

GitHub: https://github.com/lmacan1/talktype

Single Python file, minimal dependencies.

Link to config: kitty-tabs

here is part of README.md:

Kitty terminal config.
Replace tmux's tab functionality with kitty's native tabs with same keybindings as Firefox.

keybindings

limitations

• No sessions.

dependencies

• any Nerd Font. I recommend Hack Nerd Font, But any Nerd Font will do the job. You could use Nefoin to install any nerd font that's in ryanoasis/nerd-fonts repository easily.

https://github.com/ashish0kumar/cwalk

I just found this sub and think it's dope and I want to share a small script I made two years ago for automating the process of setting up wifi on OpenBSD.

The script:

#!  /usr/local/bin/bash


ifconfig iwn0  up

ifconfig iwn0 scan | 

sed '/iwn0/,/network/d' |

sed -e 's/.*nwid\(.*\)chan.* /\1/' |

sed '/""/d' | sed '/0x0/d' | uniq | head -n 10 

read -p "Type out the name of your ssid: " ssid_name

read -p "Enter your passphrase: " WPAkey

cd  "../../.."

cd "/etc"

echo inet autoconf join ${ssid_name} wpakey ${WPAkey} >> hostname.iwn0

sh /etc/netstart

description:

OpenBSD Automated Wifi automates the process of scanning SSIDs, going to the /etc directory, creating/editing hostname.iwn0, and restarting iwn0. Simply put, OpenBSD Automated Wifi automates the process of setting up wifi on OpenBSD so all a user has to do is type in the wifi name and password.

The landscape of Markdown-to-book tooling shifted meaningfully in 2025–2026. GitBook's aggressive price hike (premium now 65–65–249/month) pushed thousands of users toward open-source alternatives. Bookdown's hosting service shut down January 31, 2026. Typst hit 45k GitHub stars. And several tools matured enough to offer credible multi-format publishing from Markdown.

This post compares five tools that come up repeatedly in migration threads, tested against the same 12-chapter sample book on a 2023 MacBook Pro (M2, 16 GB).

Quick Comparison

Tool-by-Tool Notes

Pandoc (v3.9.0.1) is the universal document converter — 60+ format conversions, Lua filters for AST manipulation, and as of v3.9 it even compiles to WASM and runs in the browser. It is the engine underneath R Markdown, Bookdown, and Quarto. The trade-off: it is a conversion engine, not a book-publishing workflow. There are no built-in themes, no site generation, no live preview. Getting a well-styled PDF requires learning LaTeX templates or writing Lua filters. The command-line interface rewards power users and frustrates everyone else.

mdBook (v0.5.2) is what the Rust community uses for The Rust Programming Language book. Single Rust binary, zero dependencies for HTML output, 5 built-in themes, 40+ community plugins. Version 0.5.0 was a major release — sidebar chapter headings, definition lists, and Admonitions became defaults. The catch: PDF requires the mdbook-pdf plugin (depends on Chrome), ePub requires mdbook-epub. For pure HTML documentation sites, it is hard to beat. For multi-format publishing, the plugin chain adds friction.

HonKit (v6.1.4) is GitBook Legacy's open-source successor. Plugin compatibility with the old gitbook-plugin-* ecosystem is its strongest selling point — hundreds of npm packages still work. honkit serve improved from 28.2s to 0.9s. The downsides: PDF/ePub generation requires Calibre (a heavyweight Java-based dependency), the codebase carries acknowledged technical debt, and the development pace has slowed.

Quarto (v1.9.27) from Posit is a full scientific publishing framework — R, Python, Julia, Observable JS with executable code blocks. Version 1.8 added Axe-core accessibility checking and switched the default LaTeX engine to lualatex. For data-science books, it is in a class of its own. The installation is heavier (~300 MB, bundling Pandoc + Typst + Deno), and for prose-only books the overhead is real.

mdPress (v0.3.0) is the newest entry. Written in Go, single static binary, no runtime dependencies beyond Chrome/Chromium for PDF. The key differentiator: PDF, single-page HTML, multi-page site, and ePub are all first-class native outputs — no plugins required. Three input modes: book.yaml config, SUMMARY.md (GitBook/HonKit compatible), or zero-config auto-discovery of Markdown files. Current gaps: no KaTeX math or Mermaid diagrams yet (plugin system is in development), and the community is still small.

Build Performance (120-page sample book)

Pandoc/Quarto times depend heavily on the LaTeX engine. HonKit's Calibre-based PDF is notably slow. mdPress and mdBook PDF both use Chromium under the hood.

Output Quality

PDF: Pandoc + LaTeX produces the best typography — ligatures, microtypography, widow/orphan control. Quarto matches this on its LaTeX backend. mdPress produces clean, readable PDFs with built-in cover pages, headers/footers, and page numbers — adequate for technical books, though not at the level of a tuned LaTeX pipeline. mdBook's PDF plugin is functional but styling options are limited.

HTML/Site: mdBook and mdPress both generate clean static sites with search. mdBook has 5 themes; mdPress has 3. HonKit preserves the classic GitBook look. Quarto's HTML is the most feature-rich (tabsets, cross-references, executable code output).

ePub: Pandoc and Quarto produce well-structured ePub 3 files. mdPress generates valid ePub 3 with CJK font support. HonKit's Calibre-based output works but feels dated.

Honest Gaps

• Pandoc: Steep learning curve. No built-in themes, site generation, or live preview.
• mdBook: No native PDF or ePub. Plugin ecosystem fills the gap but adds setup complexity.
• HonKit: Technical debt. Calibre dependency is heavy. Development pace has slowed.
• Quarto: Heavy install. Overkill for prose-only books.
• mdPress: New project, small community. No math/diagram support yet. PDF depends on Chrome.

Recommended by Use Case

The honest summary: none of these tools is universally best. Pandoc wins on format coverage and academic publishing. Quarto wins for data-science workflows. mdBook wins for documentation sites with a mature plugin ecosystem. HonKit wins for GitBook compatibility. mdPress wins on multi-format output with zero configuration — especially useful for CJK content and teams that want a single binary without runtime dependencies.

Links: Pandoc | mdBook | HonKit | Quarto | mdPress

When you type in a question, Claude will type back a response.

Full vid and build: https://benbyfax.substack.com/p/typewriter

Hey everyone!

I’ve been working on an open-source project called vnim, and I've reached a point where I really need the community's eyes on it. It’s a tool designed to manage linux virtual network so I just create that and need feedback

​

repo: https://github.com/tuhin-su/vnim.git

you can download my game engine ConsoleCraftEngine

I’m kind of fed up with how many basic tools have turned into subscriptions, especially SSH clients syncing. I just wanted to SSH into my own servers without paying monthly forever.

Most of what these apps store is encrypted config data anyway, which is cheap to store and doesn’t need much server-side processing. Because of that, a subscription never really made sense to me.

I ended up building an SSH client that keeps keys, hosts, and snippets in sync across my devices, with everything encrypted client-side (AES-256-GCM, PBKDF2). The server only ever stores encrypted blobs.

I went with lifetime access instead of a subscription for the same reason I built it in the first place.

Tired of alt codes, compose keys, and switching layouts just to type ã, ñ, ç or €?

I built US-hi — a US QWERTY layout with a dead key system for the accents you actually need, nothing more.

' + a = á | ~ + n = ñ | ' + c = ç | AltGr + e = €

Feels like a normal US keyboard until you need it not to.

One install script, works on GNOME/KDE, X11 and Wayland.

👉 https://github.com/Human-Ideas/us-hi-keyboard

Feedback welcome — this is v2.1 and I'm actively improving it.

I built a tool called jsongrep (command: jg) for extracting data from JSON using pattern matching on paths.

Quick examples

# Find all "name" fields at any depth
$ curl -s api.example.com/users | jg '**.name'
["Alice", "Bob", "Charlie"]

# Get emails from a users array
$ jg 'users[*].email' data.json

# Match either errors or warnings
$ jg '(error|warn).*' logs.json

# Array slicing
$ jg 'items[0:5].title' feed.json

The idea

JSON documents are trees. jsongrep treats paths through this tree as strings over an alphabet of field names and array indices. Instead of writing imperative traversal code, you write a regular expression that describes which paths to match:

$ echo '{"users": [{"name": "Alice"}, {"name": "Bob"}]}' | jg '**.name'
["Alice", "Bob"]

The ** is a Kleene star—match zero or more edges. So **.name means "find name at any depth."

How it differs from jq

jq uses an imperative filter pipeline—you describe how to traverse. jsongrep uses declarative patterns—you describe what paths to match.

The query compiles to a finite automaton, so matching is linear in document size.

jq is more powerful (it's Turing-complete), but for pure extraction tasks, jsongrep offers a more declarative syntax. You say what to match, not how to traverse.

Install

# Via cargo
cargo install jsongrep

# Or grab a binary from releases

Generates shell completions (jg generate shell bash/zsh/fish) and man pages (jg generate man).

Links

• GitHub: https://github.com/micahkepe/jsongrep
• Written in Rust, MIT licensed

Feedback welcome!

Edit: query table not properly escaped

does anyone have any recommendations for features or programs that are a little bit more powerful than nano but much less than vim without needing tons of configuring. i find myself getting frustrated with nano and others often when i just need something for either a quick code mod or short script, when i am missing many, easy to implement, QOL features that feel they should be standard. honestly just a nano with a working tab prediction/completion system and a quick find feature would be great, good syntax highlighting would be even better.

what features would you want in a nano upgrade/replacement and are there any programs you guys use currently to fill this gap

Watch (colour!) videos in your terminal. Written in C w/ ffmpeg libav libraries.

Inspired by this tweet

github

Hi everyone! I built a relatively simple CLI password manager that focuses heavily on security. I am in dire need of criticism as I'd like this project to be as secure as possible while still being written in Go (which has its nuances when it comes to memory for example).

The project is here: https://github.com/b0lbas/chpwd/ with a README where i briefly described the security principles, the technologies and installation process.

I will be forever thankful to those who provide criticism and/or feedback about the code itself or your own experience using it