I got tired of copying Nerd Font glyphs from cheat sheets or remembering random codepoints, so I built nerdicons.

It's a Python library that provides typed, autocompletable access to every Nerd Font icon while also including a fast CLI and an interactive terminal browser.

Some examples:

from nerdicons import icons

print(icons.fa.github)
print(icons.md.home)

icons.get("fa-github")
icons.from_codepoint("f09b")

icons.search("rust")

Features:

• 🧠 Full IDE autocomplete (Pyright, Pylance, MyPy friendly)
• 🔎 Exact lookup by name, glyph, or codepoint
• ✨ Fuzzy search
• 🖥️ Interactive terminal browser
• 📋 One-key clipboard copy
• 📦 Zero runtime dependencies
• ⚡ Fast generated registry
• 🎯 Pinned to Nerd Fonts 3.5.0
• 📚 Covers 10,995 icons

CLI examples:

nerdicons search rust
nerdicons browse
nerdicons get fa-github
nerdicons copy fa-github

The browser supports keyboard navigation, live filtering, mouse scrolling, and instant clipboard copying.

I'd love feedback on the API or ideas for additional features.

GitHub:
https://github.com/programmersd21/nerdicons

PyPI:
https://pypi.org/project/nf-icons/

I pushed everything to GitHub today, so the commit history will look recent even though this has been in progress for a few months. Wanted to mention that in case it looks odd.

Wallr draws its own layer-shell surface and renders transitions itself with wgpu. It's not a wrapper around swww or hyprpaper, the point of the project was to own the rendering path so transitions are GPU-driven and timed to wall clock duration instead of tied to refresh rate.

What it does:

• 11 transition effects (fade, blur, wipe, slide, zoom, pixelate, ripple, dissolve, wave, grow, outer), each configurable from the CLI or a YAML package
• Circular reveals (grow, outer, ripple) that are aspect-corrected circles
• Live wallpapers: GIFs start playing from where the transition left off, so there's no jump into the loop
• A background daemon over a Unix socket, so wallr set talks to it instead of relaunching anything
• Directory watching, per-monitor scaling modes, and a preview window to test an effect before applying it
• Optional theme generation hookup (Matugen, Wallust, Pywal), not required to use the tool

Works on Hyprland, Sway, niri, and Plasma 6. GNOME isn't supported since Mutter doesn't implement wlr-layer-shell.

Install is cargo install wallr, or build from source. Repo and docs are here: https://github.com/programmersd21/wallr

Happy to answer questions about the renderer or the animation package format.

*music credits:

massobeats - lush

I built a Rust tool that snapshots files before destructive shell commands run, so you can undo the damage afterward.

A preexec hook intercepts every command before execution and sends it to a background daemon over a Unix socket. The daemon classifies the command, and if it's destructive, snapshots every at-risk path before the command actually runs. Files are copied (reflink on Btrfs/ZFS, plain copy elsewhere), metadata is stored in SQLite.

To undo, just run:

oops

Commands

• oops - undo the most recent snapshot
• oops undo [id] - undo a specific snapshot
• oops list - browse snapshot history (TUI)
• oops diff <id> - show files in a snapshot (TUI)
• oops status - daemon status and storage usage
• oops gc - trigger garbage collection
• oops pin/unpin <id> - exempt a snapshot from GC

Install

cargo build --release
install -Dm755 target/release/oops ~/.local/bin/oops
install -Dm644 systemd/oopsd.service ~/.config/systemd/user/oopsd.service
systemctl --user daemon-reload
systemctl --user enable --now oopsd
loginctl enable-linger "$USER"
eval "$(oops init bash)"   # or zsh, fish

Limitations

Shell-hook capture can't intercept destructive commands from cron, systemd services, GUI apps, or non-interactive shells. Only truncating redirects (> file) trigger a snapshot; fd redirects like 1>&2 are ignored. .git/ is never touched.

Retention is 48 hours or 2 GB, whichever comes first. Pinned snapshots are exempt.

MIT licensed, Linux only for now. Repo: https://github.com/programmersd21/oops

Feedback welcome.

I built Frame Studio, a tool that turns a text prompt into a rendered MP4 by having Google Gemini plan and write a Remotion video project, then compiling and rendering it server-side.

GitHub: https://github.com/programmersd21/frame_studio

Live demo: https://frame-studio-eta.vercel.app

How it works

You provide a text prompt and a Gemini API key. The backend runs a single pipeline end to end:

1. Plan — Gemini generates the video's structure from the prompt
2. Codegen — Gemini writes the React/Remotion component code
3. Compile — TypeScript validation runs in a sandbox
4. Fix — Gemini repairs compilation errors, up to 3 attempts
5. Render — Remotion renders the final MP4
6. Stream — The video streams directly to the browser for download

There's no database, no persistent storage, and no background job queue. Everything happens within the lifecycle of a single request.

Architecture

• apps/web — Next.js 15 app (webpack, not Turbopack) with API routes and UI
• packages/pipeline — prompts, schemas, and the LLM client used for planning and codegen
• packages/remotion-skeleton — the base template each generated project builds on
• workers/render-worker — compilation and rendering logic

The API key is supplied via a browser modal and stored in an HTTP-only cookie, so it isn't accessible to client-side JavaScript. A server-side fallback key can also be set via .env for local use.

Setup

bash

pnpm install
cp .env.example .env   # optional — server-side key fallback

Add a Gemini API key (from Google AI Studio) to .env:

GEMINI_API_KEY=AIzaSy...

Then run:

bash

pnpm dev

The app runs at http://localhost:3000.

Features

• Model selector across 6 Gemini models
• Real-time progress screen with pipeline stage updates
• Custom animated cursor and gradient heading
• Typing animation with motion blur
• Support for 25+ Google Fonts
• Output at 1920x1080, 30fps

Known limitations

• No queue or worker pool — concurrent renders share the same request-scoped compute, so this isn't built for high concurrency yet
• No persistence — a failed render has no retry path short of re-running the pipeline
• Compilation fixes are capped at 3 attempts; prompts that produce persistently invalid code will fail out

A note on how this was built

This project was built entirely through AI-assisted development — I directed the design and pipeline decisions, but did not hand-write the implementation myself. Sharing that up front rather than leaving it ambiguous.

Feedback on the architecture, the pipeline design, or the tradeoffs above is welcome.

License: MIT

I wrote a free, open-source book that teaches how to build a modern Wayland desktop shell using Quickshell and QML.

The book covers:

• QML from the fundamentals
• Panels, docks, launchers, widgets, notification centers, and lock screens
• Integration with Hyprland, PipeWire, MPRIS, UPower, BlueZ, and systemd
• Component architecture, theming, and project organization
• Building a complete desktop shell from scratch

Each chapter includes runnable examples, and the complete source code is available under the MIT License.

If you're interested in building your own desktop environment or learning Quickshell, I hope you find it useful.

https://github.com/programmersd21/the_quickshell_book

Four clock styles you can switch between — an analog "flower" face, a big stacked digital clock, a compact pill-shaped one, and a world clock with multiple timezones. Colors auto-match your wallpaper if you're using Matugen, or you can pick from 8 built-in themes.

Everything's controlled from one config file. Built in QML for Quickshell, MIT licensed, free to use/modify.

cp -r m3qs ~/.config/quickshell/ quickshell -p ~/.config/quickshell/m3qs

GitHub: https://github.com/programmersd21/m3qs

Happy to help if anyone wants to set it up or tweak a theme.

flow just hit 0.2.0, and it's the biggest update since launch. A quick recap for anyone new here: flow is a real time terminal bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What's new

Throughput values now actually use the spring physics the README always claimed. Numbers glide toward their targets instead of snapping, which sounds small but changes how the whole dashboard feels under load.

The ping target is now configurable. It defaulted to 1.1.1.1 and had no way to change it. Now you can set ping_target in the config or pass --ping on the command line if you want to check latency against your own gateway or a different host entirely.

There's a new streaming JSON mode. --json-stream writes one JSON object per line to stdout, continuously, so you can pipe flow into whatever else you're building. This was the most requested feature since --json and --once shipped.

Daily totals now survive restarts. They get written to ~/.config/flow/stats.json on quit and reloaded on the next launch, so closing your terminal doesn't wipe out the day's numbers anymore.

Themes are no longer limited to the 8 built in ones. Drop a .toml file into ~/.config/flow/themes/ and flow picks it up automatically at startup. Full control over colors and gradients if the defaults don't match your setup.

There's also a public roadmap now (ROADMAP.md) laying out where 0.2.x through 0.5.x are headed, and test coverage got a real pass, especially around the spring animation math and the history persistence round trip.

Since the last big writeup

If you've been following along, a lot happened between 0.1.1 and 0.1.7 too: a theme selector, bits/sec toggle, live ping indicator, a network processes panel, an interface details overlay, reset confirmation to stop accidental data loss, and a full typography and spacing pass that gave the whole UI a much more deliberate hierarchy. 0.2.0 is really the point where all of that groundwork turns into new capability instead of polish.

Usage

flow                        # hero view, auto interface
flow --compact               # numbers only
flow --tiny                  # tmux status bar
flow --json-stream            # continuous JSON Lines, new in 0.2.0
flow --ping 8.8.8.8            # custom ping target, new in 0.2.0

Install / upgrade

go install github.com/programmersd21/flow/cmd/flow@latest

Pre-built binaries for Linux, macOS, and Windows are on the releases page. Config and theme files are backward compatible, nothing to migrate.

Links

Source, changelog, and roadmap: https://github.com/programmersd21/flow

Appreciate everyone who's been using flow and sending feedback, it's shaped most of what shipped in this release. If it felt cool, a star on the repo goes a long way.

I have been working on a small Rust tool called pik. It reads newline-separated input from stdin or a file, lets you select one line interactively, and writes that selection to stdout.

git branch | pik | xargs git checkout

The scope is intentionally narrow. No fuzzy search, no multi-select, no configuration file. Navigation supports both arrow keys and vim-style bindings (j/k, g/G), along with mouse support for clicking or double-clicking a row. Exit codes are well-defined (0 for selection, 1 for error, 130 for cancellation), so it composes cleanly in scripts.

It installs as a single static binary through cargo install.

Repository: https://github.com/programmersd21/pik

If you find it useful, a star on the repository would be appreciated and helps others discover it. If you would like to support ongoing development, sponsorship is available through GitHub Sponsors on my profile.

I welcome any feedback on the design or usability.

Two weeks ago this was a side project to watch my network throughput without opening a browser tab. Now it's got 135+ stars, people running it in tmux status bars, bug reports, feature requests, and even a PR to get it into the AUR.

Flow is a terminal dashboard that does one thing: shows your download/upload speed in real time, with a calm, minimal UI - spring-animated waveforms, auto-scaling units, three display modes depending on how much space you've got. No CPU panels, no packet counters, no config required unless you want it.

What's been the best part isn't the star count: it's watching people use it in ways I didn't expect. Someone's piping the JSON output into their own dashboard. Someone else is running --tiny in their status bar. That's the whole reason to open-source something.

If you want a network monitor that gets out of your way:

go install github.com/programmersd21/flow/cmd/flow@latest

⭐ Star it if it's useful to you - it genuinely helps other people find it: https://github.com/programmersd21/flow

💛 If you want to support ongoing development, there's a Sponsor button on the repo. No pressure - stars, bug reports, and PRs are just as valuable.

Thanks to everyone who's already contributed. There's a lot more on the roadmap.

flow v0.1.1 is out

This release is mostly about making the UI work better in more environments while cleaning up a lot of rough edges.

New in this release:

• Added a new --mini mode that shows only the live graphs. Useful for smaller terminals.
• Press m to switch between Hero, Compact, Mini and Tiny views without restarting.
• The dashboard now automatically switches to a smaller layout if your terminal isn't tall enough.
• Refreshed the UI with cleaner borders, gradients and typography.
• Added a cleaner help dialog and status bar.
• Peak throughput now briefly flashes when a new session record is reached.

--tiny also got a pretty big overhaul.

It no longer depends on Bubble Tea or terminal detection, so it now works properly inside tmux #( ), cron jobs, pipes and redirected output. --tiny --no-color now produces plain text with no ANSI escape sequences.

Also fixed:

• Daily totals not resetting correctly across month/year boundaries.
• Hangs when network counter reads failed.
• Config file creation on macOS and Windows.
• Platform-specific config paths on Linux, macOS and Windows.

If flow has been useful to you, consider sponsoring the project. It helps me dedicate more time to maintaining it and building new features.

A GitHub star, bug report, or even sharing the project is just as appreciated.

https://github.com/programmersd21/flow

https://github.com/sponsors/programmersd21

I got tired of network monitors that look like they were designed for a BBS, so I built flow. It's a real time bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What it does

It shows live download and upload throughput with units that auto scale from B/s up to GB/s. The waveform is a high res Braille grid scrolling at 30fps, and the borders glow brighter as traffic picks up, going from a dark idle state to bright cyan and emerald under load. Numbers are spring interpolated so they glide instead of jumping around. It tracks session peaks, flashing white when you hit a new record, and keeps a running daily total.

There are three views that adapt to your terminal width. Hero is the full dashboard. Compact strips it down to numbers only. Tiny is a single line built for tmux status bars.

Philosophy

If a feature doesn't help you understand your network in under a second, it doesn't make the cut. No CPU panels, no packet counters, no multi pane clutter. Just download and upload throughput, done well.

Usage

flow                        # hero view, auto interface
flow --compact              # numbers only
flow --tiny                 # tmux status bar
flow --json                 # one-shot JSON for scripts
flow --once                 # one-shot plain text

tmux integration

set -g status-right "#(flow --tiny --no-color)"
set -g status-interval 1

Install

go install github.com/programmersd21/flow/cmd/flow@latest

or AUR:

yay -S flow-network-monitor-bin

or homebrew:

brew install programmersd21/flow/flow

Pre-built binaries for Linux, macOS, and Windows (amd64/arm64) are on the releases page.

It works with zero config out of the box. If you want to tweak the refresh rate, history length, or units, there's an optional TOML config at ~/.config/flow/config.toml.

Platform support

It runs on Linux (/proc/net/dev), macOS (sysctl), and Windows (GetIfTable2, no admin needed). Idle CPU stays under 1%.

Links

Source and demo: https://github.com/programmersd21/flow

---

Would love feedback, especially on the tiny/tmux mode. Curious if the info density is right for people running it in a status bar all day.

I got tired of hand-editing pyproject.toml with awkward indentation and array syntax, so I built a small terminal UI for it.

Two-pane layout (sidebar on the left, editor on the right) with full support for strings, arrays, maps, and table arrays. Editing happens inline rather than dropping you into a raw text view. Undo/redo with 50 steps, 10 themes including Tokyo Night, Catppuccin, Nord, and Gruvbox, and it adapts to whatever terminal size you're running.

Keybindings: Tab switches focus between panes, e edits a field, a adds one, d deletes, s saves, i opens the file in your system's default editor if you'd rather use that. t cycles through themes with a live preview.

Written in Go using Bubble Tea, Lipgloss, and the Bubbles list component. Runs on Windows, Linux, and macOS.

Install:

go install github.com/programmersd21/pyproject-tui/cmd/pyproject-tui@latest

Repo: https://github.com/programmersd21/pyproject-tui

Feedback's welcome, especially on the keybindings. If you find it useful, a star helps others find it too.

Topperify AI: Open-Source AI-Powered Study Material Generator

I have developed Topperify AI, a free, open-source study tool that transforms PDFs (textbooks, research papers, lecture notes) into comprehensive study materials using Google Gemini.

Generated Content

The tool produces the following study resources:

• Color-coded visual notes containing definitions, formulas, worked examples, exam tips, and memory techniques
• Interactive mind maps that display topic hierarchies and relationships
• Flashcards designed for active recall practice
• Condensed quick revision reference sheets
• High-quality dark-themed PDFs optimized for download and printing

Distinguishing Features

Topperify AI differs from comparable note-generation tools in several ways:

• Generates comprehensive, detailed content rather than basic bullet-point summaries
• Exports materials as polished glassmorphism-styled PDFs featuring dark themes, gradients, and custom typography
• Allows users to download individual PDFs, mind map images, or complete ZIP bundles
• Requires no account creation; API keys remain stored locally in browser cookies and never reach any server
• Completely free and open source under the MIT license

Technical Architecture

• Python and Streamlit for the application framework
• Google Gemini 3.1 Flash Lite for content generation
• PyMuPDF for PDF processing
• Playwright for PDF rendering
• Plotly for mind map visualization

Getting Started

1. Obtain a free Gemini API key from Google AI Studio
2. Clone the repository and execute streamlit run streamlit_app.py
3. Upload a PDF document and initiate content generation

Links

Live Demo: https://topperify.streamlit.app/ Repository: https://github.com/programmersd21/topperify_ai

If Topperify AI has been helpful, I would appreciate a star on GitHub. Your support helps the project reach more students and developers.

The project is MIT licensed, enabling self-hosting, forking, and community contributions. Feedback from students and developers is welcome. What features would enhance this tool?

aur_checker: Static Analysis + AI for PKGBUILD Security

Given the recent supply chain attacks on 400+ AUR packages (Atomic Arch campaign, June 2026), we built a tool to address a real gap in AUR security workflows.

The Problem

The AUR attack showed a clear vulnerability: malicious PKGBUILD modifications executed silently during package builds. Standard signature checks miss this because the original source code remains clean. The attack vector is in the build script itself.

Current workflow: download PKGBUILD, read it manually, hope you catch obfuscation or malicious patterns. That doesn't scale.

What aur_checker Does

Three-layer analysis:

1. Static Detection - Flags 7 high-risk patterns:

   • Remote code execution (piped downloads: curl | bash)
   • Obfuscation (base64, hex, eval chains)
   • Suspicious package manager calls
   • System modifications to /etc, /usr/lib, /boot
   • Orphaned packages (adoption attack vector)

2. Metadata Check - AUR RPC data: maintainer history, orphan status, age

3. AI Review - Claude/Gemini analyzes code context and logic flow (70% weight in final score)

Final output: 0-100 risk score + verbose reasoning.

How to Use

aur_checker check keepassx2
aur_checker batch --file packages.txt
aur_checker check --json firefox-bin  # pipe to tools

Why This Matters Now

Post-Atomic Arch, the community consensus is clear: always review PKGBUILD before building. The problem is human review doesn't scale and misses obfuscation.

This tool doesn't replace manual inspection, but it surfaces the right questions to ask:

• Is that base64 string necessary?
• Why does this post-install hook call npm?
• Did the maintainer just change?

Installation

git clone https://github.com/programmersd21/aur_checker.git
cd aur_checker
pip install -e .
export AURCHECKER_AI_API_KEY="your-key"

Requires: Python 3.10+, Google Generative AI API key (free tier works)

Limitations (Honest)

• Static regex-based; sophisticated obfuscation might slip through
• AI analysis is heuristic, not bulletproof
• Still requires user judgment for final decisions
• False positives possible (some packages legitimately call package managers)

GitHub

programmersd21/aur_checker

If this helps secure your AUR workflow, consider starring the repo or sponsoring development. Keeps the project maintained and signals priority to other users.

MIT license. Feedback welcome.

---

Context for non-Arch folks: The AUR is like npm/pip but for Arch—community-maintained packages you build locally. No central review. The Atomic Arch attack compromised 400+ packages by taking over orphaned builds and injecting malware into PKGBUILD scripts. This tool helps surface that attack pattern programmatically.