Open-Source Log Management Tools Compared: Loki, VictoriaLogs, Parseable, OpenSearch & More

Which open-source log management tool should you self-host in 2026? This article compares purpose-built log platforms (Grafana Loki, VictoriaLogs, Parseable, CLP, ZincSearch), general search databases used for logs (OpenSearch, Elasticsearch), log collectors and pipelines (Fluent Bit, Fluentd, syslog-ng), and CLI analysis tools — covering architecture, query languages, storage efficiency, full-text search, and operational complexity.

Logs are the cheapest signal to produce and the most expensive to store (commercial SaaS bills often reach $0.10–$2.50/GB; see our paid observability pricing breakdown). Choosing the right self-hosted backend is a cost decision as much as a feature one.

TL;DR — Quick Recommendations

Use case	Best fit	Runner-up
Object-storage-first, cost-optimized at scale	Loki	Parseable
Lowest ops overhead, single binary	VictoriaLogs	ZincSearch
SQL access to logs	Parseable	—
Grafana/PromQL ecosystem	Loki	VictoriaLogs
Extreme compression (archival)	CLP	Loki (ZSTD)
Elasticsearch replacement (lightweight)	ZincSearch	VictoriaLogs
Full-text search at scale	OpenSearch	Elasticsearch
Kubernetes log shipper	Fluent Bit	Loggie
Apache 2.0 license required	VictoriaLogs	CLP

Jump to Section 1 for dedicated log backends or When to Use What for the full decision table.

This article focuses exclusively on open-source, self-hostable tools primarily intended for logs — no mandatory commercial licenses, no mandatory SaaS accounts. Using a strict definition, the log-specific ecosystem is smaller than the metrics world.

Excluded: Multi-signal observability platforms (OpenObserve, SigNoz, ClickStack, OneUptime, HyperDX), general analytical databases (ClickHouse), and managed services. These are covered in our companion guide Open-Source Observability Platforms Compared. For empirical ingestion throughput and storage compaction benchmarks on identical hardware, see Benchmarking Open-Source Observability.

---

Table of Contents

• Scope & Selection Criteria
• Legend
• Section 1: Log Storage, Search and Analytics Platforms
  • The Candidates
  • Architecture Classification
  • Feature Comparison
  • Query Language Comparison
  • Storage Architecture & Efficiency
  • Ingestion & Protocol Support
  • Operational Complexity
  • When to Use What
  • Known Limitations
• Section 2: General Search Databases Commonly Used for Logs
  • The Candidates
  • Comparison
  • Licensing Notes
• Section 3: Complete Open-Source Log-Management Interfaces
  • The Candidates
  • Comparison
• Section 4: Open-Source Log Collectors and Pipelines
  • The Candidates
  • Comparison
  • When to Use What
• Section 5: Log Viewing and Command-Line Analysis Tools
• Section 6: Open-Source Application Logging Libraries
• Recommended Evaluation Scope
• Benchmark & Migration Tools
• FAQ
• References

---

Scope & Selection Criteria

Criterion	Requirement
Open-source	OSI-approved license or well-known open license
Self-hostable	Runs entirely on your infrastructure
No mandatory commercial license	Free edition covers primary log functionality
No mandatory SaaS account	No phone-home, no cloud signup required
Primarily designed for logs	Not a multi-signal observability platform that also does logs

---

Legend

Symbol	Meaning
✅	Supported / available
◐	Partial support or requires additional setup / integration
⭐	Particular strength or best-in-class
—	Not supported or not applicable

---

Section 1: Log Storage, Search and Analytics Platforms

These are the closest equivalents to Loki and VictoriaLogs — purpose-built log backends.

The Candidates

Platform	License	Query Language	Storage Model	Full-text Search	UI Included	GitHub	Positioning
Grafana Loki	AGPLv3	LogQL	Filesystem or object storage	Limited; label-first	No; use Grafana	⭐ 25k+ · 👥 800+ · Since 2018	Industry standard for Grafana users
VictoriaLogs	Apache 2.0	LogsQL	Local storage	Yes	Basic UI / Grafana	⭐ 17.6k (mono-repo) · 👥 400+ · Since 2023 (VL)	Lightest self-hosted log DB
Parseable	AGPLv3	SQL-oriented query APIs	Object storage	Yes	Yes	⭐ 4k+ · 👥 50+ · Since 2022	SQL-first log analytics
CLP	Apache 2.0	CLP search/query interfaces	Highly compressed log archives	Yes	Yes	⭐ 2k+ · 👥 30+ · Since 2021	Compression-specialized archival
ZincSearch	Apache 2.0	Elasticsearch-compatible APIs	Local / object-oriented	Yes	Yes	⭐ 17k+ · 👥 70+ · Since 2021	Lightweight ES alternative

Quickwit note: Quickwit (AGPLv3, Rust, object-storage-first, Elasticsearch-compatible API) was acquired by Datadog in 2025. Its historical open-source code remains available, but it should not be treated as an actively independent project for new long-term deployments. Datadog acquisition announcement.

LogDevice note: LogDevice (BSD) is a distributed append-only log store, not an observability log-search platform. Its repository is archived. Not comparable with Loki.

Architecture Classification

graph TB
    subgraph "Label-Indexed / Stream-Based"
        direction LR
        LOKI[Loki<br/>Labels → streams → chunks on object storage]
        VL[VictoriaLogs<br/>LogsQL, columnar, stream-oriented]
    end

    subgraph "Object-Storage-First Analytics"
        direction LR
        PR[Parseable<br/>Parquet on S3/MinIO/local]
    end

    subgraph "Compression-Specialized"
        direction LR
        CLP_NODE[CLP<br/>Domain-specific compression + search]
    end

    subgraph "Lightweight Search Engine"
        direction LR
        ZS[ZincSearch<br/>Bluge index, ES-compatible API]
    end

Architecture	Trade-off
Label-indexed / stream-based	Cheap storage, fast recent queries by label; full-text search requires filter expressions
Object-storage analytics	Lowest cost at rest; columnar format good for aggregations
Compression-specialized	Extreme compression ratios; specialized query interface
Lightweight search	Easy to deploy; limited scale compared to distributed systems

Feature Comparison

Criterion	Loki	VictoriaLogs	Parseable	CLP	ZincSearch
Full-text search	◐ (line filter, not inverted index)	⭐	✅	⭐ (on compressed data)	⭐
Structured log support	✅ (detected fields)	⭐	⭐ (schema-on-read)	✅	✅
Aggregation queries	✅ (LogQL metric queries)	✅	✅ (SQL)	◐	◐
Alerting	✅ (ruler)	✅ (vmalert)	✅	—	—
Live tail	✅	✅	✅	◐	◐
Multi-tenancy	⭐	✅	✅	—	—
Log pattern detection	⭐	—	—	⭐ (native)	—
RBAC	✅ (via Grafana)	◐	✅	—	✅
High availability	⭐ (microservices mode)	◐ (replication planned)	✅ (distributed mode)	—	—
Retention policies	✅ (per-tenant)	✅	✅	Manual	◐

Query Language Comparison

Tool	Language	Style	Full-text syntax	Aggregations	Joins	Learning curve
Loki	LogQL	PromQL-like (pairs natively with Prometheus/Mimir and Tempo tracing)	\|= "error", \|~ "regex"	✅ (metric queries)	—	Medium (if you know PromQL)
VictoriaLogs	LogsQL	Purpose-built log query	"error", _msg:~"regex"	✅	—	Low
Parseable	SQL (via API)	Standard SQL	WHERE message LIKE '%error%'	⭐	✅	Low (SQL)
CLP	CLP query syntax	Specialized	Wildcard/substring on compressed	◐	—	Medium
ZincSearch	ES-compatible	Lucene/ES DSL	message: error	◐	—	Low-Medium (if you know ES)

Storage Architecture & Efficiency

Tool	Storage model	Object storage native	Compression	Expected ratio (structured JSON)	Index strategy
Loki	Chunks on object storage; label index (TSDB/BoltDB)	⭐	Snappy / Gzip / LZ4 / ZSTD	5–10x	Labels only (no full-text index)
VictoriaLogs	Columnar + dictionary encoding on local disk	✅ (planned/limited)	LZ4 / ZSTD	10–30x	Column-based with full-text
Parseable	Parquet files on object storage	⭐	Parquet + ZSTD	10–20x	Columnar + row-group filters
CLP	Domain-specific encoding (variable/dictionary)	◐	Custom (extreme ratios)	20–100x+ (claimed)	Specialized search on compressed
ZincSearch	Bluge segments (inverted index)	◐	Segment compression	2–5x	Full inverted index

CLP’s compression ratios are exceptional because it exploits log-specific structure (repeated templates with variable components). This comes with a more specialized query model.

Ingestion & Protocol Support

Tool	OTLP	Syslog	Fluent Bit / Fluentd	HTTP/JSON push	Kafka	Promtail/Alloy
Loki	✅ (via Alloy/OTel Collector)	✅ (via agent)	⭐	✅ (push API)	✅	⭐ (Alloy)
VictoriaLogs	✅	✅	⭐	⭐ (Elasticsearch-compatible)	✅	—
Parseable	✅	◐ (via collector)	✅	⭐ (native HTTP)	✅	—
CLP	◐	◐	◐	◐ (file/stream-based)	—	—
ZincSearch	◐	◐	✅	⭐ (ES-compatible bulk API)	◐	—

Operational Complexity

Tool	Min RAM (useful)	Single binary	External dependencies	Upgrade path	Team size needed
Loki	2 GB	◐ (monolithic mode)	Object storage (prod)	Schema versions; plan ahead	1–2
VictoriaLogs	512 MB	⭐	None	Simple	1
Parseable	1 GB	⭐	Object storage (optional)	Simple	1
CLP	1 GB+	◐	None	Manual (archives)	1
ZincSearch	512 MB	⭐	None	Simple	1

When to Use What

If you need…	Best fit	Runner-up
Object-storage-first, cost-optimized at scale	Loki	Parseable
Lowest operational overhead, single binary	VictoriaLogs	ZincSearch
SQL access to logs	Parseable	—
PromQL/LogQL ecosystem (Grafana native)	Loki	VictoriaLogs (Grafana plugin)
Extreme compression (archival/cold storage)	CLP	Loki (ZSTD)
Elasticsearch drop-in replacement (lightweight)	ZincSearch	VictoriaLogs (ES-compat API)
Minimal footprint (edge, small team)	VictoriaLogs	ZincSearch
Multi-tenant SaaS-style log platform	Loki	Parseable
Pattern detection / log structure analysis	Loki (pattern detection)	CLP
Apache 2.0 license requirement	VictoriaLogs	CLP
Existing Prometheus/Grafana investment	Loki	VictoriaLogs

Known Limitations

Tool	Key limitation
Loki	Not designed for high-cardinality labels; full-text search requires filter expressions, not free-text index; schema version migrations require planning
VictoriaLogs	Younger project; scaling/replication story still maturing; object-storage support limited
Parseable	Newer project; ecosystem integrations still growing; not yet battle-tested at extreme scale
CLP	Specialized query model — not a general-purpose log search engine; limited ecosystem integration
ZincSearch	Single-node only; no distributed mode; smaller community; limited aggregation capabilities

---

Section 2: General Search Databases Commonly Used for Logs

These are open-source and free to self-host, but they are not exclusively log databases. Included because log management is one of their primary production uses.

The Candidates

Platform	License	Log Stack	Strength	Strictly logs-only?
OpenSearch	Apache 2.0	OpenSearch + Dashboards + collector	Full-text search, analytics, alerting (⭐ 10k · 👥 400+ · Since 2021)	No
Apache Solr	Apache 2.0	Solr + log shipper	Mature Lucene search (⭐ 1.2k · Since 2006)	No
Apache Lucene	Apache 2.0	Embedded / custom application	Search library underlying many log systems (⭐ 2.8k · Since 1999)	No
Elasticsearch	Multiple (AGPL v3 core since 8.16; Elastic License 2.0 some features)	Elasticsearch + Kibana	Rich search and analytics (⭐ 71k · 👥 2,000+ · Since 2010)	No

OpenSearch is the safest fully Apache-licensed alternative for building an Elasticsearch-style log stack.

Comparison

Tool	Full-text search	Structured fields	Aggregations	Alerting	Object storage	Operational overhead	Min RAM
OpenSearch	⭐	⭐	⭐	⭐	✅ (remote store)	Medium-High (JVM tuning)	4 GB+
Solr	⭐	⭐	✅	◐	◐	Medium-High	4 GB+
Lucene	⭐	⭐	✅	— (library)	—	N/A (embedded)	—
Elasticsearch	⭐	⭐	⭐	⭐ (Watcher)	✅ (frozen tier)	Medium-High (JVM tuning)	4 GB+

Licensing Notes

• OpenSearch: Apache 2.0 throughout — safest for any deployment model
• Elasticsearch: Core is AGPL v3 since 8.16+; some features under Elastic License 2.0; ML/anomaly detection requires Platinum/Enterprise (paid)
• Solr / Lucene: Apache 2.0, fully open

---

Section 3: Complete Open-Source Log-Management Interfaces

UIs and platforms that provide log exploration, search, dashboards, and alerting — typically backed by one of the storage engines above.

The Candidates

Tool	License	Backend	Purpose
OpenSearch Dashboards	Apache 2.0	OpenSearch	Search, dashboards, alerting (⭐ 1.7k · Since 2021)
Grafana	AGPLv3	Loki, VictoriaLogs, OpenSearch, ES	Log exploration and dashboards (⭐ 66k · Since 2013)
Kibana	AGPL v3 / ELv2	Elasticsearch	Log search and visualization (⭐ 20k · Since 2013)
Graylog Open	Source-available (not strictly OSI)	OpenSearch / data node	Complete log management (⭐ 7.5k · Since 2010)
Dozzle	MIT	Docker runtime	Live Docker log viewer (⭐ 7k+ · Since 2018)
Logdy	Apache 2.0	Local streams / files	Browser-based local log viewer (⭐ 1k+ · Since 2023)
lnav	BSD-2-Clause	Local files / journal	Terminal log analysis (⭐ 7.5k · Since 2007)
GoAccess	MIT	Access-log files	Real-time web access-log analytics (⭐ 19k · Since 2010)

Graylog clarification: Graylog can be used without paying in some configurations, but its current server licensing is source-available rather than conventional OSI-approved open source. Treat it as a separate “free / source-available” category.

Comparison

Tool	Full search	Dashboards	Alerting	Multi-user	Deployment complexity	Best for
OpenSearch Dashboards	⭐	⭐	⭐	✅	Medium (needs OpenSearch)	Full log analytics
Grafana	⭐	⭐	⭐	⭐	Low (stateless)	Multi-backend exploration
Kibana	⭐	⭐	⭐	✅	Medium (needs ES)	Elastic ecosystem
Graylog Open	⭐	✅	⭐	✅	Medium-High	All-in-one log management
Dozzle	✅	—	—	◐	Very low	Docker container logs
Logdy	✅	—	—	—	Very low	Local dev/debugging
lnav	⭐	—	—	—	None (single binary)	Terminal log analysis
GoAccess	✅	✅ (access-log specific)	—	—	Very low	Web server access logs

---

Section 4: Open-Source Log Collectors and Pipelines

These collect, parse, enrich, and forward logs but do not normally provide long-term storage.

The Candidates

Tool	License	Logs only?	Best use
Fluent Bit	Apache 2.0	Primarily logs, also metrics/traces	Lightweight Kubernetes and edge agent (⭐ 6k · 👥 400+ · Since 2014 · CNCF Incubating)
Vector	MPL-2.0	Primarily logs, also metrics/traces	High-throughput, memory-safe Rust pipeline and aggregator (⭐ 18.5k · 👥 400+ · Since 2019)
Fluentd	Apache 2.0	Primarily logs	Central log aggregation and routing (⭐ 13k · 👥 400+ · Since 2011 · CNCF Graduated)
Logstash	Dual (Apache 2.0 / ELv2)	Primarily events/logs	Complex parsing and Elasticsearch pipelines (⭐ 14.3k · 👥 500+ · Since 2009)
syslog-ng OSE	GPL / LGPL	Yes	Syslog collection, processing, routing (⭐ 2.3k · 👥 100+ · Since 1998)
rsyslog	GPL v3 / Apache 2.0	Yes	High-performance Linux/syslog collection (⭐ 2.1k · 👥 80+ · Since 2004)
Loggie	Apache 2.0	Primarily logs	Kubernetes-native log collection (⭐ 1.3k · 👥 30+ · Since 2021)
Fluent Operator	Apache 2.0	Primarily logs	Manage Fluent Bit/Fluentd in Kubernetes (⭐ 600+ · 👥 50+ · Since 2020)
Logging Operator	Apache 2.0	Primarily logs	Kubernetes logging pipelines (⭐ 1.6k · 👥 80+ · Since 2018 · CNCF Sandbox)
Filebeat	Dual (Apache 2.0 / ELv2)	Yes	Lightweight file and container log shipper (⭐ 12.3k mono-repo · 👥 600+ · Since 2014)
Promtail	AGPLv3	Yes	Legacy Loki agent; EOL March 2026 (part of Loki repo · Since 2018)
Grafana Alloy	Apache 2.0	No (multi-signal)	Official Promtail successor — collects logs, metrics, traces, profiles; OTel-compatible (⭐ 1.5k · 👥 200+ · Since 2024)

Promtail note: Promtail reached end of life in March 2026. For new Loki installations, use Fluent Bit, Vector, Grafana Alloy, or an OpenTelemetry-based collector instead. Alloy and OpenTelemetry Collector are multi-signal tools and do not belong in a strict log-only list.

Comparison

Tool	Syslog native	File tailing	Container/K8s	Parsing/enrichment	Multi-output	Backpressure handling	Resource footprint
Fluent Bit	✅	⭐	⭐	✅ (filters)	⭐	✅	Very low (~15 MB)
Vector	✅	⭐	⭐	⭐ (VRL)	⭐	✅	Low (~30 MB, Rust)
Fluentd	✅	⭐	⭐	⭐ (plugins)	⭐	✅	Medium (~100 MB)
Logstash	✅	✅	✅	⭐ (grok, dissect)	⭐	✅	High (JVM, 500 MB+)
syslog-ng	⭐	✅	◐	⭐ (parsers, rewrite)	✅	✅	Low
rsyslog	⭐	✅	◐	✅ (rainerscript)	✅	✅	Very low
Loggie	◐	✅	⭐	✅	✅	✅	Low
Fluent Operator	—	—	⭐ (manages FB/FD)	— (delegated)	—	—	Low (operator)
Logging Operator	—	—	⭐ (manages FB/FD)	— (delegated)	—	—	Low (operator)
Filebeat	◐	⭐	✅	✅ (processors)	◐	✅	Low (~50 MB)
Promtail	◐	✅	✅	✅ (pipeline stages)	— (Loki only)	✅	Low
Grafana Alloy	✅	⭐	⭐	⭐ (OTel processors)	⭐	✅	Medium (~100 MB)

When to Use What

If you need…	Best fit	Runner-up
Lightweight K8s log shipper	Fluent Bit	Loggie
High-throughput Rust pipeline & VRL transforms	Vector	Fluent Bit
Central aggregator with rich routing	Fluentd	Vector
Complex parsing (grok, multi-line)	Logstash	Fluentd
Syslog infrastructure (RFC5424)	syslog-ng	rsyslog
Maximum throughput syslog receiver	rsyslog	syslog-ng
Elastic/OpenSearch shipper	Filebeat	Fluent Bit
K8s logging with GitOps management	Fluent Operator / Logging Operator	—
Loki shipper (new deployment)	Fluent Bit	Grafana Alloy (multi-signal)

---

Section 5: Log Viewing and Command-Line Analysis Tools

Useful for local troubleshooting but not centralized log platforms.

Tool	Purpose
lnav	Interactive terminal log viewer with parsing and SQL queries
GoAccess	NGINX / Apache access-log analytics (real-time)
Angle Grinder (ag)	Slice and aggregate structured logs from terminal
jq	JSON log processing
Miller	Process JSON, CSV, and structured records
Stern	Tail logs from multiple Kubernetes pods
Kubetail	Kubernetes log viewer
kail	Tail Kubernetes logs by workload or label
MultiTail	View multiple log files simultaneously
Logwatch	Periodic Linux log summaries
AWStats	Web and access-log analytics

---

Section 6: Open-Source Application Logging Libraries

These generate structured application logs but do not collect or store them.

Ecosystem	Libraries
Java / Kotlin	SLF4J, Logback, Log4j 2
Go	zap, zerolog, standard library slog
Python	Standard logging, structlog, Loguru
Node.js	Pino, Winston, Bunyan
.NET	Serilog, NLog
Rust	tracing, log
PHP	Monolog

---

Recommended Evaluation Scope

For a modern open-source log-platform benchmark, evaluate:

Priority	Platform	Why include
1	Loki	Label-indexed, object-storage-oriented baseline
2	VictoriaLogs	Efficient log-specific database with LogsQL
3	Parseable	Modern object-storage-based log analytics with SQL
4	OpenSearch	Full-text indexed search baseline (general-purpose but primary log use)
5	CLP	Compression-focused architecture
6	ZincSearch	Lightweight Elasticsearch-style alternative

Evaluate collectors separately:

• Fluent Bit
• Fluentd
• syslog-ng
• rsyslog
• Loggie

---

Benchmark & Migration Tools

Tool	License	Purpose	GitHub
log-collectors-benchmark	Apache 2.0	Benchmarks log collector agents (Fluent Bit, Vector, Alloy, etc.) on ingestion throughput and resource usage	⭐ 27 · 👥 1
sql-to-logsql	Apache 2.0	Converts SQL queries to LogsQL syntax for migrating to VictoriaLogs	⭐ 36 · 👥 3

---

FAQ

What is the best open-source alternative to Splunk? For centralized log search with dashboards and alerting, OpenSearch (with OpenSearch Dashboards) is the closest feature-complete Splunk alternative. For a lighter-weight, more modern approach, Loki + Grafana or VictoriaLogs offer lower operational overhead at the cost of less rich full-text search.

Should I use Loki or Elasticsearch/OpenSearch for logs? Loki if you want low storage costs (object storage), already use Grafana, and primarily filter logs by labels (service, namespace, pod). OpenSearch/Elasticsearch if you need powerful full-text search across arbitrary log fields, complex aggregations, or an Elasticsearch-compatible API. Loki is cheaper to run; OpenSearch is more capable for ad-hoc text search.

What is the lightest self-hosted log backend? VictoriaLogs — runs as a single binary with 512 MB RAM, no external dependencies, and achieves 10–30x compression. ZincSearch is similarly light but has weaker aggregation capabilities.

Is Loki good for full-text search? Loki was designed for label-based filtering with line-level grep (|= "error"), not inverted-index full-text search. It works well when you filter by stream labels first, then search within matching lines. For free-text search across all logs without knowing labels, OpenSearch or VictoriaLogs are better fits.

Which log collector should I use in Kubernetes? Fluent Bit — it’s the CNCF-graduated standard, extremely low footprint (~15 MB), native Kubernetes metadata enrichment, and outputs to Loki, OpenSearch, Elasticsearch, and OTLP. For GitOps-managed pipelines, pair it with Fluent Operator or Logging Operator.

What happened to Quickwit? Quickwit was acquired by Datadog in 2025. Its open-source code remains on GitHub but is no longer independently maintained. Do not adopt it for new long-term deployments.

🧭 The Complete Observability Guide & Comparison Series

• Unified Platforms: Open-Source Observability Platforms Compared
• Hands-On Testing: Benchmarking Open-Source Observability: Real Hardware & Ingestion Numbers
• Cost & Licensing Analysis: Paid Observability Platforms & Enterprise Pricing Comparison
• Deep-Dive Specialized Signal Guides:
  • Logging: Open-Source Log Management Tools Compared (Loki, VictoriaLogs, Parseable, CLP)
  • Metrics & TSDBs: Open-Source Metrics Tools & Time-Series DBs Compared
  • Distributed Tracing: Open-Source Distributed Tracing Tools Compared (Jaeger, Tempo, Zipkin)
  • Continuous Profiling: Open-Source Continuous Profiling Tools Compared (Pyroscope, Parca, Perforator)

---

References

Log Platforms

• Grafana Loki Documentation
• VictoriaLogs Documentation
• VictoriaLogs GitHub
• Parseable Documentation
• CLP GitHub
• ZincSearch GitHub
• Quickwit (archived context)

Benchmark & Migration Tools

• log-collectors-benchmark
• sql-to-logsql

Search Databases

• OpenSearch Documentation
• Elasticsearch Guide
• Apache Solr Documentation
• Apache Lucene

Log Interfaces

• OpenSearch Dashboards
• Grafana
• Kibana
• Graylog
• Dozzle
• lnav
• GoAccess

Log Collectors

• Fluent Bit Documentation
• Vector Documentation
• Fluentd Documentation
• syslog-ng Documentation
• rsyslog Documentation
• Loggie
• Fluent Operator
• Logging Operator

CLI Tools

• lnav
• GoAccess
• Angle Grinder
• jq
• Miller
• Stern

---

Last verified: September 2026. Features, licensing, and performance characteristics change — always check official sources.