DEV Community: nazdridoy

Supercharge Your Workflow: AI Chatbots, CLI Magic, and Smarter AI Usage with nGPT

nazdridoy — Wed, 14 May 2025 23:43:33 +0000

Supercharge Your Workflow: AI Chatbots, CLI Magic, and Smarter AI Usage with nGPT

Let's be honest: AI is everywhere these days. From the apps on our phones to the tools we use at work, artificial intelligence is quietly (and sometimes not-so-quietly) reshaping how we get things done. But for many of us, the real magic happens when AI becomes a true partner, helping us brainstorm, automate the boring stuff, and even spark a little creativity when we need it most.

If you've ever wished you could have a super-smart assistant right in your terminal, or wondered how to use AI in ways that are actually practical (and not just hype), you're in the right place. In this post, we'll explore the world of AI chatbots and command-line tools, share some best practices for getting the most out of AI, and introduce you to nGPT, a powerful, flexible CLI tool that brings the best of AI right to your fingertips.

The Power of AI Chatbots: Beyond Just Talking

When most people think of AI chatbots, they picture a friendly assistant answering questions or maybe helping with customer support. But modern AI chatbots are so much more than that. They can help you:

Brainstorm ideas for your next project
Summarize long articles or documents
Write and debug code
Translate languages
Draft emails, blog posts, or even poetry

The real magic is in how conversational AI can adapt to your needs. It's not just about getting answers, it's about having a partner that helps you think, create, and solve problems faster.

Why the Command Line? The Case for CLI AI Tools

If you're a developer or power user, you know the command line is where productivity happens. It's fast, scriptable, and always at your fingertips. So why not bring AI there too?

AI-powered CLI tools let you:

Automate repetitive tasks with a single command
Integrate AI into your existing workflows (think: piping, scripting, chaining commands)
Stay focused, no need to switch windows or context
Get instant, context-aware help right where you work

Plus, CLI tools are lightweight and often more customizable than their GUI counterparts. For many, it's the perfect blend of power and flexibility.

Good Practices for Using AI Effectively

AI is powerful, but it's not magic. Here are a few tips to get the most out of your AI tools:

Be specific with your prompts: The clearer your question or instruction, the better the AI's response.
Iterate and refine: Don't be afraid to ask follow-up questions or tweak your prompts for better results.
Double-check important outputs: AI can make mistakes, always review code, commands, or critical content before using it.
Use AI as a collaborator, not a crutch: Let AI handle the heavy lifting, but keep your own judgment in the loop.
Respect privacy and security: Don't share sensitive data with AI tools unless you trust the provider and understand their policies.

With the right approach, AI can be a game-changer, helping you work smarter, not just harder.

Meet nGPT: The Swiss Army Knife for AI in Your Terminal

So, what if you could combine the power of modern AI with the speed and flexibility of the command line? That's exactly what nGPT does. Think of it as your all-in-one AI assistant, ready to help you brainstorm, code, automate, and more, all from your terminal.

nGPT is a lightweight, open-source CLI tool that connects you to powerful AI models (like OpenAI, Groq, Claude, Gemini, and more) with a single command. It's designed for speed, flexibility, and real productivity, no bloat, just results.

Key Features

💬 Chat with AI in your terminal (interactive or one-off)
🧠 Generate and prettify code with syntax highlighting
🔄 Rewrite and summarize text
💻 Generate shell commands tailored to your OS
🧩 Create AI-powered git commit messages
🔍 Integrate web search for up-to-date answers
⚙️ Flexible configuration and provider switching (OpenAI, Ollama, Groq, Claude, Gemini, etc.)
📝 Conversation logging, markdown rendering, and more

Real-World Demonstrations with nGPT

Let's see nGPT in action! Here are some practical ways you can use it every day:

Quick Q&A and Coding

# Get a quick explanation
ngpt "Explain the difference between threads and processes in Python"

# Generate code with real-time syntax highlighting
ngpt --code --stream-prettify "Write a Python function to reverse a linked list"

With the --code flag, nGPT gives you clean code without explanations or markdown, just what you need to copy and paste into your project. The --stream-prettify option shows real-time syntax highlighting as the code comes in.

Shell Command Generation (OS-Aware)

# Let nGPT generate the correct command for your OS
ngpt --shell "list all files in the current directory including hidden ones"
# On Linux/macOS: ls -la
# On Windows: dir /a

One of my favorite features! No more Googling obscure command flags, nGPT generates the right command for your operating system. It'll even execute it for you if you approve.

Text Rewriting and Summarization

# Pipe text to rewrite it (e.g., improve clarity)
echo "This is a rough draft of my email." | ngpt -r

# Summarize a file using the pipe placeholder
cat long-article.txt | ngpt -p "Summarize this document concisely: {}"

The text rewriting feature is perfect for quickly improving documentation, emails, or reports. And with pipe placeholders, you can feed in content from files or other commands.

Git Commit Message Generation

# Stage your changes
git add .

# Let nGPT generate a conventional commit message based on the diff
ngpt -g

# Generate git commit message from a diff file
ngpt -g --diff changes.diff

This is a huge time-saver. nGPT analyzes your git diff and generates a properly formatted conventional commit message that actually describes what you changed. No more staring at the blank commit message prompt!

Web Search Integration

# Ask questions that require up-to-date information
ngpt --web-search "What's the latest news about AI regulation?"

The --web-search flag lets nGPT consult the web for recent information, making it useful for questions about current events or topics that might have changed since the AI's training data cutoff.

Advanced Features & Customization

Multiple AI Providers in Your Pocket

One of the coolest things about nGPT is how it lets you switch between different AI providers with a single parameter. Working on code? Maybe you prefer Claude. Need creative writing help? OpenAI might be your go-to. Using models locally? Ollama has you covered.

# Use OpenAI for a complex coding task
ngpt --provider OpenAI --code "Create a Python implementation of radix sort"

# Use Groq for fast responses
ngpt --provider Groq "Write a product description for hiking boots"

# Use a local Ollama model for privacy-sensitive work
ngpt --provider Ollama "Help me refactor this internal documentation"

You can set up multiple configurations and switch between them effortlessly:

# Show all your configured providers
ngpt --show-config --all

# List available models for a specific provider
ngpt --list-models --provider Gemini

Customizing Your Experience

nGPT offers a flexible CLI configuration system that lets you set defaults for your most commonly used options:

# Set Java as your default language for code generation
ngpt --cli-config set language java

# Always use a higher temperature for more creative tasks
ngpt --cli-config set temperature 0.9

# Set Gemini as your default provider
ngpt --cli-config set provider Gemini

# Show all CLI settings
ngpt --cli-config get

This means you can tailor nGPT to your specific workflow needs without having to repeat the same flags every time.

Real-World Integration Examples

Let's look at how nGPT can fit into your everyday workflow with some practical examples:

Developer Workflow

As a developer, I use nGPT throughout my day:

Morning code review:

   # Get explanations of complex code
   git show | ngpt -p "Explain what this code change does and any potential issues: {}"

Debugging help:

   # Help understand a cryptic error message
   npm run build 2>&1 | grep Error | ngpt -p "What does this error mean and how can I fix it: {}"

Documentation generation:

   # Generate JSDoc comments for functions
   cat src/utils.js | ngpt -p "Write proper JSDoc comments for these functions: {}"

Commit messages:

   # After finishing a feature
   git add .
   ngpt -g

Writer's Assistant

For content creators and writers:

Overcoming writer's block:

   ngpt "Give me 5 different angles to approach an article about sustainable technology"

Editing assistance:

   cat draft.md | ngpt -r

Research summaries:

   curl -s https://example.com/research-paper.html | ngpt -p "Summarize the key findings from this research: {}"

System Administrator

For sysadmins and DevOps folks:

Generating complex commands:

   ngpt -s "find all log files larger than 100MB that haven't been modified in the last 30 days"

Creating configuration files*:

   ngpt --code "Create a Docker Compose file for a Redis, PostgreSQL, and Node.js application"

Troubleshooting systems:

   dmesg | tail -50 | ngpt -p "Explain what might be causing the issues based on these system logs: {}"

Tips for Getting the Most Out of AI Tools

Let's wrap up with some real-world advice for making AI your best digital sidekick:

Start simple, then get creative: Don't worry about crafting the perfect prompt on your first try. Start with a basic question or task, see what the AI gives you, and then refine from there.
Mix and match tools: Use AI alongside your favorite command-line utilities. Pipe, chain, and script to create powerful workflows that save you time and effort.
Keep learning: AI models are always improving, and new features pop up all the time. Check the docs, try new flags, and don't be afraid to experiment.
Stay in control: Remember, AI is here to help, not to take over. Always review outputs, especially for code, commands, or anything that could impact your system or data.
Share your wins (and fails): The AI community is full of people learning together. Share your cool use cases, clever prompts, or even the funny mistakes, someone else will appreciate it.

Conclusion: The Future of AI in Everyday Work

AI isn't just a futuristic concept anymore, it's a practical tool that can genuinely enhance how we work, especially when integrated thoughtfully into our existing workflows. Whether you're brainstorming ideas, writing code, managing commits, or just need a quick answer, AI assistants accessed through the command line, like nGPT, offer a powerful blend of speed, flexibility, and intelligence.

By embracing these tools and following good practices, being specific, iterating, verifying, and respecting privacy, we can move beyond the hype and make AI a true collaborator. The future isn't about AI replacing us; it's about AI empowering us to be more productive, creative, and focused on the tasks that matter most.

Ready to supercharge your own workflow? Give nGPT a try! You can find it on GitHub or install it with a simple pip install ngpt. Happy automating!

Documentation & Installation

For more details, guides, and advanced usage, check out the official documentation:

Installation

# Install via pip
pip install ngpt

# Or install with uv (faster installation)
uv pip install ngpt

# Or install globally as a CLI tool (recommended for command-line usage)
uv tool install ngpt

# Arch Linux: install from AUR
paru -S ngpt

Requires Python 3.8 or newer.

For more installation options and troubleshooting, see the Installation Guide.

Craft Better Commit Messages with Conventional Commits and Visual Labels

nazdridoy — Sat, 03 May 2025 14:49:21 +0000

Craft Better Commit Messages with Conventional Commits and Visual Labels

Have you ever looked at a project's commit history and struggled to understand what changes were made and why? Or spent hours trying to find a specific feature addition or bug fix among hundreds of vague commit messages? You're not alone. The way we document our code changes can make the difference between a maintainable, collaborative project and a confusing mess of undocumented changes.

In this post, we'll explore the power of good commit messages through conventional commits and introduce you to GitHub Commit Labels - a nifty tool that transforms your commit history into an easy-to-navigate, visually informative timeline that both humans and tools can understand.

Why Good Commit Messages Matter

When we think about documentation, we often focus on READMEs, inline comments, and API docs. But commit messages are arguably your project's most important documentation:

They tell a story: Well-structured commits create a narrative of how your project evolved
They save time: Clear messages make it easy to find when and why changes were introduced
They streamline debugging: Good commit messages help you quickly identify potential sources of bugs
They facilitate collaboration: New team members can understand the codebase's evolution
They enable automation: Structured messages can power release notes, changelogs, and semantic versioning

The difference between "Fixed stuff" and "fix(authentication): resolve token expiration issue causing random logouts" is enormous. The latter immediately tells you what component was affected, what the issue was, and what user impact it had.

Enter Conventional Commits

Conventional Commits is a specification for adding human and machine-readable meaning to commit messages. It's a simple set of rules that creates a standardized format:

type(scope): description

[optional body]

[optional footer(s)]

Let's break it down:

Type: Categorizes the change (e.g., feat, fix, docs, style, refactor)
Scope: Specifies what part of the codebase was changed (optional)
Description: A short summary of the changes
Body: Detailed explanation of the changes (optional)
Footer: Information about breaking changes or issue references (optional)

Here are some examples:

feat(auth): implement OAuth2 authentication flow

fix(api): handle rate limiting errors

docs(readme): add installation guide

style(button): improve hover effects

refactor!(parser): rewrite parser logic (breaking change)

The exclamation mark in the last example indicates a breaking change – immediately signaling to other developers that this commit requires attention during updates.

Adopting conventional commits offers several advantages:

Automatic versioning: Tools can determine the next semantic version based on commit types
Automated changelogs: Generate release notes directly from commits
Searchable history: Easily find all bug fixes or feature additions
Clearer communication: Everyone understands the purpose of each commit
Onboarding friendly: New contributors can learn the project patterns

But as powerful as conventional commits are, they're still just text. What if we could make them even more visual and intuitive?

Introducing GitHub Commit Labels

GitHub Commit Labels is a userscript that transforms conventional commit messages into beautiful, color-coded labels directly in your GitHub interface. It automatically detects commit types and adds visually appealing labels to make your commit history more readable at a glance.

Key Features

🏷️ Adds beautiful labels to conventional commit messages
🎨 GitHub-style design that matches the platform
🌓 Automatic theme detection (light, dark, and dark dimmed)
💬 Informative tooltips showing detailed descriptions
👆 Toggle button to quickly show/hide labels
📤 Export/Import configurations for team sharing
⚙️ Fully customizable through a user-friendly configuration panel
🔄 Supports multiple aliases for each commit type
🎯 Works on commit history and single commit pages
⚠️ Special highlighting for BREAKING CHANGES

The result is a commit history that tells you, at a glance, what kind of changes each commit contains:

🟢 Green for new features and additions
🟣 Purple for bug fixes
🔵 Blue for documentation changes
🟠 Orange for build and deployment updates
🔴 Red for breaking changes

With GitHub Commit Labels, you can see the big picture of your project's evolution without reading each commit message in detail.

Getting Started with GitHub Commit Labels

Installation is straightforward:

Install a userscript manager:
- Tampermonkey (Recommended)
- Greasemonkey
- Violentmonkey
Install the script:
- Install from Greasy Fork

That's it! Now visit any GitHub repository with conventional commits to see the transformation:

Not seeing labels? GitHub Commit Labels works with conventional commit formats. If a repository doesn't use them, you won't see any labels. But don't worry - you can start using conventional commits in your projects today!

Customizing Your Experience

GitHub Commit Labels is highly customizable through its configuration panel:

To access it:

Click on your userscript manager's icon and select "GitHub Commit Labels" > "Configure Commit Labels"

On any GitHub commit history page, look for the ⚙️ gear icon button in the lower right corner of the screen

Here you can:

Add/remove commit types
Edit aliases
Change emojis
Modify colors
Toggle prefix removal
Enable/disable tooltips
Show/hide floating toggle button
Export/Import your configuration

The default configuration supports over 20 commit types, including:

Feature: feat, feature
Added: added, add
Fix: fix, bugfix, fixed
Documentation: docs, doc, documentation
Style: style, css
Refactor: refactor
Performance: perf, performance
Test: test, tests, testing
Build: build
Chore: chore
Revert: revert
Security: security
And many more!

You can add your own custom types or modify existing ones to match your team's workflow.

Start Writing Better Commit Messages

Ready to improve your own commit messages? Here are some tips:

Be specific: Explain what changed and why
Use the imperative mood: Write "Add feature" not "Added feature"
Keep the first line under 50 characters: This ensures good formatting in various Git tools
Reference issues: Link to issue numbers when applicable
Focus on impact: Explain the "why" not just the "what"
Be consistent: Stick to your chosen convention

Following these guidelines alongside conventional commits will dramatically improve your repository's readability.

Integration with nGPT: AI-Generated Conventional Commits

Want to generate perfect conventional commit messages automatically? nGPT provides a powerful CLI tool that can analyze your changes and create well-formatted commits.

# After staging your changes with git add, run:
ngpt -g

nGPT will analyze your git diff and generate a conventional commit message like:

feat(auth): implement OAuth2 authentication flow

- [feat] Create new AuthService class to handle token management
- [feat] Implement login/logout functionality in UserController
- [feat] Add configuration options for OAuth providers
- [Update] Update user model to store OAuth tokens
- [feat] Add unit tests for authentication flow

When this commit appears in GitHub, GitHub Commit Labels will automatically add a visually appealing "Feature" label next to the commit message.

Want to learn more about nGPT and its other powerful features? Check out the full article: Supercharge Your Workflow: AI Chatbots, CLI Magic, and Smarter AI Usage with nGPT.

Conclusion: A More Beautiful, Functional Git History

Conventional commits and GitHub Commit Labels together transform the way you interact with your Git history. They turn a wall of text into a visually meaningful timeline that can be understood at a glance, searched by type, or used to automate releases.

By adopting these practices, you:

Make your repository more maintainable
Improve team communication
Enable powerful automation
Create a foundation for better software versioning
Make your GitHub interface more beautiful and functional

Whether you're maintaining a personal project or working on a large team, investing in better commit messages pays dividends in productivity and clarity.

Ready to get started? Install GitHub Commit Labels today and begin writing more meaningful commits. Your future self and team members will thank you.

For more information, visit the GitHub Commit Labels repository.

Additional Resources

Natural Text-to-Speech with Kokoro TTS

nazdridoy — Sat, 03 May 2025 09:33:26 +0000

Natural Text-to-Speech with Kokoro TTS

Text-to-speech has come a long way from the robotic voices of the past. Today's TTS technology can produce remarkably natural-sounding speech that's nearly indistinguishable from human voices. But for many users, access to high-quality voice synthesis has meant wrestling with complex interfaces or limited options.

What if you could have studio-quality voice synthesis right in your terminal? What if converting text to speech was as simple as typing a single command? That's exactly what Kokoro TTS delivers.

In this post, we'll explore the world of natural text-to-speech, why command-line tools make sense for voice synthesis, and introduce you to Kokoro TTS, a powerful CLI tool that brings professional-grade voice synthesis to your fingertips.

The Evolution of Text-to-Speech: From Robotic to Natural

Modern TTS has transformed dramatically from the mechanical-sounding systems of the past. Today's neural TTS systems like Kokoro can:

Create incredibly natural-sounding speech with appropriate intonation and rhythm
Support multiple languages and regional accents
Offer diverse voice options across genders and speaking styles
Blend different voices for customized output
Handle complex texts including books and technical documents

The result is audio that sounds genuinely human, making it perfect for audiobook creation, accessibility solutions, content consumption, and more.

Why the Command Line for TTS?

For power users, content creators, and developers, the command line offers distinct advantages:

Automate voice generation with scripts and batch processing
Integrate TTS into existing workflows and pipelines
Process large documents efficiently without GUI overhead
Customize output with precise parameter control
Save time with keyboard-driven operation

CLI tools strip away unnecessary complexity while offering maximum flexibility, perfect for when you need to convert large amounts of text or integrate voice synthesis into other applications.

Meet Kokoro TTS: Professional Voice Synthesis in Your Terminal

Kokoro TTS is an open-source CLI tool that delivers high-quality text-to-speech right from your terminal. Think of it as your personal voice studio, capable of transforming any text into natural-sounding speech with minimal effort.

Listen to Kokoro TTS in Action

Want to hear how natural it sounds? Check out these demos:

🎧 Audio Demo: Listen to MP3 Sample

For higher quality audio, you can also download the WAV sample.

Your browser does not support the video tag.

Note: For the best experience, download the demos and play them locally.

Key Features

🌐 Multiple language support with 30+ high-quality voices
🔀 Voice blending with customizable weights for unique sound profiles
📚 Support for EPUB books, PDF documents, and plain text
🔊 Real-time streaming audio playback
📑 Automatic chapter detection and processing
⏩ Adjustable speech speed
🎵 Multiple audio format outputs (WAV, MP3)
📋 Standard input and pipe support for flexible workflows
🖥️ GPU acceleration for faster processing

Real-World Demonstrations with Kokoro TTS

Let's see Kokoro TTS in action with some practical examples:

Basic Text-to-Speech Conversion

# Convert a text file to speech
kokoro-tts input.txt output.wav --speed 1.2 --voice af_sarah

# Stream audio directly without saving
kokoro-tts input.txt --stream --speed 0.8

The streaming feature is perfect for quickly previewing how text will sound without waiting for file processing to complete.

Working with Books and Documents

# Convert an entire EPUB book to audio chapters
kokoro-tts my-favorite-book.epub --split-output ./audiobook/ --format mp3

# Process a PDF document with automatic chapter detection
kokoro-tts business-report.pdf --split-output ./audio-report/ --format wav

For book lovers, this feature is game-changing. Imagine turning your entire e-book library into a personal audiobook collection with a single command.

Voice Blending for Custom Voices

# Create a custom voice by blending two voices (60-40 mix)
kokoro-tts input.txt output.wav --voice "af_sarah:60,am_adam:40"

# Use equal voice blend (50-50)
kokoro-tts input.txt --stream --voice "am_adam,af_sarah"

Voice blending lets you create unique voice profiles by mixing different voices together, perfect for creating distinctive narration for different characters or projects.

Piping from Other Tools

# Pipe text directly from another command
cat README.md | kokoro-tts /dev/stdin --stream

# Real-time news reading from an RSS feed
curl -s https://news-feed.com/rss | grep -o "<title>.*</title>" | sed 's/<[^>]*>//g' | kokoro-tts /dev/stdin --stream

The pipe support makes Kokoro TTS extremely versatile, allowing it to fit into complex workflows with other command-line tools.

Advanced Features & Customization

Language and Voice Selection

Kokoro TTS supports multiple languages and voice types:

# List all available voices
kokoro-tts --help-voices

# Use a British English voice
kokoro-tts input.txt output.wav --voice bf_emma --lang en-gb

# Try a Japanese voice
kokoro-tts japanese-text.txt output.wav --voice jf_alpha --lang ja

With voices spanning English (US and UK), French, Italian, Japanese, and Chinese, you can create audio in the language that suits your needs.

Processing Long Documents

For longer texts, Kokoro TTS offers smart chunking and merging:

# Process a long document in chunks
kokoro-tts long-document.txt --split-output ./chunks/ --format mp3

# Merge existing chunks into chapter files
kokoro-tts --merge-chunks --split-output ./chunks/ --format wav

This approach makes it possible to process even very long texts efficiently, with organized output files.

Debugging and Customization

# Get detailed information about processing
kokoro-tts input.epub --split-output ./chunks/ --debug

# Adjust speed for faster playback
kokoro-tts input.txt output.wav --speed 1.5

The debug option is particularly helpful when processing complex documents with nested chapters or when troubleshooting any issues.

Real-World Integration Examples

Let's explore how Kokoro TTS fits into everyday workflows:

Content Creator Workflow

For content creators and educators:

Blog to podcast conversion:

   # Convert blog posts to audio for podcast supplements
   kokoro-tts blog-post.md podcast-episode.mp3 --voice bf_emma --speed 1.1

Course material preparation:

   # Convert lecture notes to audio lectures
   find ./course-notes -name "*.txt" -exec kokoro-tts {} {}.mp3 --voice am_eric \;

Social media content:

   # Create voiceovers for short videos
   kokoro-tts script.txt voiceover.wav --voice af_nova --speed 1.2

Accessibility Solutions

For accessibility needs:

Document reading:

   # Convert important documents to audio
   kokoro-tts important-notice.txt audio-notice.mp3 --voice af_sarah

Book accessibility:

   # Make e-books accessible
   kokoro-tts book.epub --split-output ./audiobook/ --format mp3

Web content consumption:

   # Extract and read article text
   curl -s https://example.com/article | html2text | kokoro-tts /dev/stdin --stream

Developer Use Cases

For developers integrating TTS:

Testing voice interfaces:

   # Generate test responses for voice applications
   cat test-responses.txt | kokoro-tts /dev/stdin test-audio.wav

CI/CD pipeline integration:

   # Automatically generate audio versions of documentation
   git diff --name-only | grep "\.md$" | xargs -I{} kokoro-tts {} {}.mp3

Notification systems:

   # Create custom audio notifications
   echo "Build completed successfully" | kokoro-tts /dev/stdin notification.wav

Installation

Getting started with Kokoro TTS is straightforward:

# Clone the repository
git clone https://github.com/nazdridoy/kokoro-tts.git
cd kokoro-tts

# Install required packages
pip install -r requirements.txt
# or use uv for faster installation
uv sync

# Download model files
wget https://github.com/nazdridoy/kokoro-tts/releases/download/v1.0.0/voices-v1.0.bin
wget https://github.com/nazdridoy/kokoro-tts/releases/download/v1.0.0/kokoro-v1.0.onnx

Requires Python 3.12.

Conclusion: The Future of Text-to-Speech

The line between synthetic and human speech continues to blur as tools like Kokoro TTS make high-quality voice synthesis accessible to everyone. By bringing professional-grade TTS to the command line, Kokoro opens up new possibilities for content creation, accessibility, learning, and productivity.

Whether you're creating audiobooks from your e-book collection, making documents more accessible, or integrating voice into your applications, Kokoro TTS offers the perfect blend of simplicity and power. The future of TTS isn't just about technology that can speak, it's about technology that can speak naturally, expressively, and in a way that truly engages listeners.

Ready to transform your text into natural speech? Give Kokoro TTS a try and discover how easy professional voice synthesis can be.

For more details, visit GitHub or consult the README for complete documentation.