Open Source Tools & Libraries

A curated directory of well-known open-source projects — dev utilities, file tools, AI stacks and security software. Each entry includes a use case, why we recommend it, and a Tentaco alternative when one fits.

48 curated projects

Dev Tools

CLI utilities and libraries that speed up everyday development.

ripgrep

Ultra-fast recursive grep that respects .gitignore and skips binary files.

Use case: Search large codebases from the terminal without waiting on slow find/grep combos.
Why it's good: Rust-powered speed, sensible defaults, and regex support that feels instant on million-line trees.

fzf

Interactive fuzzy finder for files, command history, git branches and more.

Use case: Pipe any list into fzf and pick an item with keyboard-driven fuzzy search.
Why it's good: Tiny binary, works everywhere, and composes cleanly with Unix pipes and shell bindings.

lazygit

Terminal UI for Git — stage hunks, rebase, resolve conflicts visually.

Use case: Handle everyday Git workflows without memorising dozens of subcommands.
Why it's good: Keyboard-first but approachable; makes complex operations like interactive rebases far less painful.

HTTPie

Friendly HTTP client for the CLI with syntax-highlighted output and JSON support.

Use case: Quickly probe REST APIs, debug headers, and iterate on requests during development.
Why it's good: Readable command syntax and polished output beat curl one-liners for exploratory API work.

bat

cat clone with syntax highlighting, Git integration and automatic paging.

Use case: Preview source files in the terminal with line numbers and language-aware colours.
Why it's good: Drop-in replacement for cat that makes reading code in a shell genuinely pleasant.

jq

Command-line JSON processor — filter, map and transform structured data.

Use case: Slice API responses, extract fields from logs, and pipe JSON through shell scripts.
Why it's good: The de-facto standard for JSON on the CLI; expressive query language with a tiny footprint.

Vite

Next-generation frontend build tool with instant HMR and lean production bundles.

Use case: Scaffold React, Vue or Svelte apps with a dev server that starts in milliseconds.
Why it's good: ESM-native, plugin ecosystem, and the default choice for modern SPA tooling.

Biome

Fast formatter and linter for JavaScript, TypeScript, JSON and CSS in one toolchain.

Use case: Replace ESLint + Prettier with a single Rust-powered binary in CI and editors.
Why it's good: Dramatically faster than JS-based linters and ships sensible defaults out of the box.

Deno

Secure JavaScript and TypeScript runtime with built-in tooling and web-standard APIs.

Use case: Run scripts, serve apps and manage dependencies without npm or node_modules bloat.
Why it's good: TypeScript-first, permission model, and a single executable for dev and deploy.

Docker

Platform for building, shipping and running applications in containers.

Use case: Package services with reproducible environments for local dev and production deploys.
Why it's good: Industry standard for isolating dependencies and matching prod-like setups on any machine.

Neovim

Hyper-extensible Vim-based editor focused on modern UX and Lua configuration.

Use case: Edit code in the terminal with LSP, treesitter and a rich plugin ecosystem.
Why it's good: Keyboard-driven editing with near-zero latency and infinite customization.

Tauri

Build tiny cross-platform desktop apps with web frontends and Rust backends.

Use case: Ship native installers for Windows, macOS and Linux without Electron's memory footprint.
Why it's good: Uses the OS webview — dramatically smaller binaries and better battery life.

File Tools

Convert, inspect and move files across formats and storage.

FFmpeg

The swiss-army knife for audio, video and multimedia transcoding.

Use case: Convert formats, trim clips, extract audio tracks and batch-process media files.
Why it's good: Supports virtually every codec; battle-tested in production pipelines worldwide.

ImageMagick

Create, edit and convert bitmap images from the command line.

Use case: Resize batches of images, strip metadata, apply filters and build thumbnails in scripts.
Why it's good: Decades of format coverage and a rich operator language for automated image pipelines.

fd

Simple, fast alternative to find with intuitive defaults and coloured output.

Use case: Locate files by name or extension without wrestling with find's syntax.
Why it's good: Respects .gitignore out of the box and feels natural for day-to-day file discovery.

rclone

Sync and mount files across cloud storage providers from one CLI.

Use case: Mirror buckets, back up folders to S3/Drive/Backblaze and script cross-cloud migrations.
Why it's good: Unified interface for 70+ backends with encryption, bandwidth limits and resume support.

QPDF

Structural PDF transformation — merge, split, rotate and linearize without re-rendering.

Use case: Automate PDF page manipulation in scripts while preserving vector quality.
Why it's good: Lossless page-level operations and a stable CLI trusted by document pipelines.

ExifTool

Read, write and edit metadata in images, videos, PDFs and hundreds of formats.

Use case: Strip GPS tags before sharing photos or batch-rename files from EXIF dates.
Why it's good: Unmatched format breadth and a single tool for privacy-focused metadata cleanup.

HandBrake

Open-source video transcoder for converting and compressing video from almost any format.

Use case: Batch-encode DVDs, screen recordings and camera footage to H.264 or H.265.
Why it's good: GUI and CLI, presets for common devices, and rock-solid encoding quality.

pngquant

Lossy PNG compressor that converts 24/32-bit PNGs to palette PNGs with alpha.

Use case: Shrink PNG assets for the web while keeping transparency.
Why it's good: Often cuts PNG size by 50–70% with visually imperceptible quality loss.

Zstandard

Fast real-time compression algorithm with high ratios and dictionary training.

Use case: Compress logs, backups and archives faster than gzip with better ratios.
Why it's good: Used by Facebook, Linux kernel and countless backup pipelines worldwide.

rsync

Efficient file sync and transfer utility with delta encoding over the network.

Use case: Mirror directories to servers, back up incrementally and resume interrupted transfers.
Why it's good: Only sends changed blocks — indispensable for DevOps and personal backups.

7-Zip

File archiver with high compression ratio and support for many archive formats.

Use case: Pack and unpack 7z, zip, tar and more from the CLI or GUI.
Why it's good: 7z format often beats zip by a wide margin; p7zip ports it to Linux and macOS.

Syncthing

Continuous file synchronization between devices without a central cloud server.

Use case: Keep folders in sync across laptops, phones and NAS boxes on your LAN or over the internet.
Why it's good: End-to-end encrypted, open protocol, and you own the data — no subscription.

AI Utilities

Open models, inference stacks and frameworks for local AI.

Ollama

Run open-weight LLMs locally with a simple CLI and model library.

Use case: Prototype chat apps, summarise documents and experiment with models on your own hardware.
Why it's good: One-command model pulls, OpenAI-compatible API, and low friction for offline inference.

Whisper

OpenAI's speech-recognition model — robust transcription across languages.

Use case: Transcribe podcasts, meetings and videos locally without sending audio to a cloud API.
Why it's good: Strong out-of-the-box accuracy and open weights you can run on CPU or GPU.

llama.cpp

Efficient C/C++ inference for LLaMA-family models on CPU and Apple Silicon.

Use case: Serve quantised models with minimal RAM on laptops and embedded devices.
Why it's good: Pioneered practical quantisation; huge community and bindings for every language.

Open WebUI

Self-hosted ChatGPT-style interface for local and remote LLM backends.

Use case: Give teams a familiar chat UI pointed at Ollama, OpenAI or other compatible APIs.
Why it's good: Polished UX, RAG plugins and multi-user support without vendor lock-in.

LangChain

Framework for building LLM apps — chains, agents, retrieval and tool calling.

Use case: Wire models to documents, APIs and databases when building production AI features.
Why it's good: Huge integration catalog and patterns for RAG, evaluation and observability.

Transformers

Hugging Face library for state-of-the-art NLP, vision and audio models.

Use case: Fine-tune, evaluate and deploy pretrained models with a few lines of Python.
Why it's good: The hub ecosystem, pipelines API and trainer make experimentation remarkably fast.

ComfyUI

Node-based GUI for Stable Diffusion with powerful workflow composition.

Use case: Build reusable image-generation pipelines with control nets, upscalers and LoRAs.
Why it's good: Visual graph editing beats one-off prompts for repeatable creative workflows.

llamafile

Package and run LLMs as a single executable that works on most computers.

Use case: Distribute local AI models to teammates without complex Python environments.
Why it's good: One file, CPU and GPU support, and no dependency hell.

KoboldCpp

Easy-to-use local LLM runner with a built-in web UI and API compatibility.

Use case: Run GGUF models on consumer GPUs with story-writing and chat interfaces.
Why it's good: Low barrier to entry for local inference compared to raw llama.cpp setup.

Stable Diffusion WebUI

Automatic1111's feature-rich web interface for Stable Diffusion image generation.

Use case: Generate, inpaint and upscale images with extensions and a huge community.
Why it's good: The most documented local SD stack — endless tutorials and plugins.

LiteLLM

Unified API gateway for 100+ LLM providers with OpenAI-compatible endpoints.

Use case: Switch models in apps without rewriting client code; add logging, budgets and fallbacks.
Why it's good: One interface for OpenAI, Anthropic, Ollama and more — ideal for prototyping.

Chroma

Open-source embedding database for AI applications and semantic search.

Use case: Store document embeddings for RAG pipelines and similarity queries.
Why it's good: Simple Python API, runs locally, and integrates cleanly with LangChain.

Security Tools

Encryption, auditing and analysis tools for safer systems.

OWASP ZAP

Dynamic application security testing proxy for finding web vulnerabilities.

Use case: Spider and scan staging sites for XSS, injection flaws and misconfigurations.
Why it's good: Free, actively maintained by OWASP, with both GUI and automation-friendly APIs.

Wireshark

Network protocol analyser for capturing and inspecting packets in depth.

Use case: Debug API latency, trace TLS handshakes and investigate suspicious traffic.
Why it's good: Industry-standard dissectors and filters; indispensable for network troubleshooting.

Gitleaks

Static scanner that detects hard-coded secrets in Git repos and CI pipelines.

Use case: Run in pre-commit hooks or CI to block API keys and tokens before they ship.
Why it's good: Fast, low false-positive tuning and easy integration with GitHub Actions.

age

Modern file encryption tool with simple keys and small, auditable codebase.

Use case: Encrypt backups and secrets files for storage or sharing with passphrase or SSH keys.
Why it's good: Designed as a successor to GPG for files — minimal UX friction and strong crypto defaults.

KeePassXC

Cross-platform password manager with local encrypted databases.

Use case: Store credentials offline, auto-type logins and sync via your own cloud folder.
Why it's good: No subscription, full control of your vault file, and browser integration on all major OSes.

OpenSSL

Cryptography toolkit for TLS, certificates, hashing and encryption primitives.

Use case: Generate CSRs, inspect certificates, compute digests and test TLS endpoints.
Why it's good: Ubiquitous, scriptable and the foundation most of the web's TLS stack builds on.

Nuclei

Fast vulnerability scanner powered by a large community template library.

Use case: Scan web apps and infrastructure for known CVEs and misconfigurations in CI.
Why it's good: YAML templates are easy to write; thousands of checks ship ready to use.

HashiCorp Vault

Secrets management, encryption and privileged access for infrastructure.

Use case: Rotate API keys, issue dynamic database credentials and audit secret access.
Why it's good: Industry standard for teams that outgrew .env files and shared password spreadsheets.

Bitwarden CLI

Command-line access to Bitwarden vaults for scripting and automation.

Use case: Inject secrets into deploy scripts and CI without hardcoding passwords.
Why it's good: Open-source core, self-hostable, and integrates with existing Bitwarden accounts.

Trivy

Comprehensive security scanner for containers, filesystems and IaC configs.

Use case: Find CVEs in Docker images and misconfigurations in Terraform before deploy.
Why it's good: Single binary, fast scans, and excellent CI integration (GitHub Actions, GitLab).

Fail2ban

Intrusion prevention framework that bans IPs after repeated failed logins.

Use case: Protect SSH, web and mail servers from brute-force attacks automatically.
Why it's good: Battle-tested on millions of Linux servers; configurable jails for any log format.

Cosign

Container signing, verification and transparency for software supply chains.

Use case: Sign OCI images in CI and enforce signature verification in Kubernetes admission.
Why it's good: Part of Sigstore — makes artifact signing accessible without managing PKI yourself.