Forem: 1234567890-

Designing a practical sorting benchmark across Python, Rust, and C

1234567890- — Mon, 20 Apr 2026 07:04:14 +0000

I recently built a sorting playground, and one question kept coming up:

How do you compare and evaluate sorting algorithms?

Not just theoretically, but in practice.

The problem

A simple benchmark sounds easy:

run the same algorithm
measure time
compare

But it quickly becomes complicated:

Python vs Rust vs C behave very differently
large inputs can break CI pipelines
some algorithms are not even benchmarkable

The approach

Instead of chasing perfect accuracy, I focused on something else:

consistency and reproducibility

Key decisions

run benchmarks in CI (GitHub Actions)
use fixed datasets
run multiple iterations
average results

Input sizes

small
medium
large

But not every language runs all sizes (due to runtime issues).

The reality of cross-language benchmarking

One important thing I learned:

Not all languages should run the same workload.

For example:

Rust / C / C++ can handle large datasets easily
Python can become extremely slow on large inputs
running everything “fairly” is not practical

Practical constraints

So I introduced constraints:

Python skips large datasets
heavy algorithms are limited
some algorithms opt out entirely

This makes the system:

fast enough to run in CI
stable
still useful for comparison

Incremental benchmarking

Another key idea:

don’t re-run everything

new algorithms → benchmarked
existing ones → reused

This keeps CI time under control.

What the system produces

Each algorithm gets:

per-language results
per-size measurements
aggregated data

The output is stored as static JSON and rendered in the UI.

Why build this?

Because combining:

visualization
comparison
and reproducible benchmarks

makes algorithms much easier to understand.

Future ideas

more languages
better scoring models
workload-specific comparisons

But always keeping it simple enough to run.

If you’re interested, you can explore it here (Open sourced under the MIT license):

https://sorting.1234567890.dev/benchmark
https://github.com/T-1234567890/sort-playground

I built a sorting playground to visualize real, weird, and absurd algorithms

1234567890- — Mon, 20 Apr 2026 06:57:21 +0000

I’ve been experimenting with sorting algorithms recently, and I realized something:

Most explanations are static.

You read code, you see diagrams, but you don’t actually see what’s happening step by step.

So I built a small project to explore that.

https://sorting.1234567890.dev

What it does

The idea is simple:

pick a sorting algorithm
watch every step
compare it with others
export the result

It includes both:

classic algorithms (Merge Sort, Quick Sort)
and weird / meme ones (like Miracle Sort or random-based sorts)

Why the weird ones?

Some sorting algorithms don’t really make sense in practice.

one does nothing and just keeps checking
one randomly swaps elements until it works
one removes anything that doesn’t fit

They’re not useful, but they’re interesting to observe.

And once you visualize them, they become surprisingly fun.

Features

step-by-step visualization
side-by-side comparison
export as image/GIF/embed
support for multiple implementations

A small experiment

This project wasn’t meant to be a product.

It started as something I built for fun, just to see how different algorithms behave visually.

But it turned into something I kept using myself.

What’s next

I’ve started building a system around it:

community ranking
benchmark comparisons
experimental features

Still keeping it lightweight.

If you have ideas, algorithms, or improvements, feel free to share.

This project is open source (MIT), and contributions are welcome.

A modular terminal toolbox with a plugin system (tinfo v1.0)

1234567890- — Thu, 19 Mar 2026 13:18:21 +0000

Terminal Info CLI v1.0

I’ve been working on Terminal Info (tinfo), a CLI written in Rust.

It started as a simple system info tool, but grew into a modular terminal toolbox with a plugin-based design.

What you get out of the box

Run tinfo and you get a clean dashboard (location/weather/time/network/CPU/memory). There are commands for:

weather + time
ping/latency/network
system + disk/storage
diagnostics groups
server mode for VPS environments
--json, --plain, --compact output modes
shell completions (bash, zsh, fish)
profiles + theming via ~/.tinfo/config.toml

The “one CLI, many tools” plugin model

Terminal Info routes subcommands to executables:

Instead of building a one use CLI, the goal is to keep the core small and let functionality grow through plugins.

tinfo <plugin-name>    # resolves to tinfo-<plugin-name>

Managed plugins live under:

~/.terminal-info/plugins/<plugin-name>/

There’s a “self-hosted” style registry in the repo: a small plugins/index.json and one JSON per plugin. The registry pins exact versions—Terminal Info won’t automatically install “latest”. Installs verify:

the author’s Minisign signature
trust a plugin before it executes

Discovery & management:

tinfo plugin search <query>
tinfo plugin install <name>
tinfo plugin trust <name>
tinfo plugin update <name>
tinfo plugin list

Writing a plugin in ~5 minutes (with the SDK)

The project includes a Rust plugin SDK crate, tinfo-plugin. A typical workflow:

tinfo plugin init weather
cd tinfo-weather
cargo run -- --metadata
cargo test

tinfo plugin keygen --output-dir ./keys
tinfo plugin pack
tinfo plugin publish-check

The template ships a release workflow, a manifest (plugin.toml), a smoke test harness, and it automatically supports:

--metadata
--help

Plugin metadata declares plugin_api = 1.

Security expectations

Plugins are third-party executables. They run as your user (no automatic elevation), and if a plugin asks for sudo, treat that as a big red flag.

Repo: https://github.com/T-1234567890/terminal-info

If you’re building plugins or thinking about extending tinfo, jump in, open a PR, share your ideas, or just start experimenting. If you have any questions or any problems, please let me know in the GitHub Discussions or open an Issue!

Building an Extensible Rust CLI Toolbox with a Plugin System

1234567890- — Tue, 17 Mar 2026 09:55:59 +0000

I recently built a project called terminal-info, a Rust CLI toolbox designed to display useful system and environment information directly in the terminal.

GitHub: https://github.com/T-1234567890/terminal-info

The project originally started as a small terminal weather CLI, but over time, it developed into something closer to a CLI toolbox with plugins.

Instead of being a single-purpose tool, the goal is to make it extensible so developers can add their own tools and diagnostics.

What terminal-info does

Running the CLI shows a simple dashboard with useful information:

┌──────────────────────────────────┐
│           Terminal Info          │
├──────────────────────────────────┤
│ Location: Shenzhen               │
│ Weather: Clear sky, 20.3°C       │
│ Time: 2026-03-16 xx:xx:xx        │
│ Network: xxx.xxx.x.xx            │
│ CPU: 19.3%                       │
│ Memory: 16.2 GiB / 24.0 GiB used │
└──────────────────────────────────┘

The dashboard is only the default overview.

Terminal Info provides many additional commands and plugins
for diagnostics, networking, system information, and developer tools.

Why I added a plugin system

While building the CLI, I realized that many terminal tools are limited by being fixed-feature applications.

For example:

system info tools
monitoring tools
diagnostics utilities

They are useful, but extending them often requires modifying the core codebase.

So I developed terminal-info CLI with a plugin system.

The idea is simple:

core CLI
+ plugin SDK
+ plugin registry

Developers can write plugins that extend the CLI without modifying the main repository.

Security considerations

One challenge with plugin systems is security.

To address this, the project includes:

signed plugin releases
integrity verification
registry review
local trust controls

Users must explicitly trust a plugin before it can run.

Project goals

The long-term goal is to turn terminal-info into a general-purpose CLI toolbox where new functionality can live as plugins.

Instead of replacing existing tools, the idea is to provide a platform where small terminal utilities can coexist and evolve.

Feedback welcome

The project is still early and I would really appreciate feedback from the community, especially on the plugin architecture and developer experience.

GitHub: https://github.com/T-1234567890/terminal-info
Docs: https://github.com/T-1234567890/terminal-info/tree/main/docs

The project is open source and licensed under Apache 2.0.

Building an Extensible Rust CLI Toolbox with a Plugin System

1234567890- — Tue, 17 Mar 2026 09:55:59 +0000

I recently built a project called terminal-info, a Rust CLI toolbox designed to display useful system and environment information directly in the terminal.

GitHub: https://github.com/T-1234567890/terminal-info

The project originally started as a small terminal weather CLI, but over time, it developed into something closer to a CLI toolbox with plugins.

Instead of being a single-purpose tool, the goal is to make it extensible so developers can add their own tools and diagnostics.

What terminal-info does

Running the CLI shows a simple dashboard with useful information:

┌──────────────────────────────────┐
│           Terminal Info          │
├──────────────────────────────────┤
│ Location: Shenzhen               │
│ Weather: Clear sky, 20.3°C       │
│ Time: 2026-03-16 xx:xx:xx        │
│ Network: xxx.xxx.x.xx            │
│ CPU: 19.3%                       │
│ Memory: 16.2 GiB / 24.0 GiB used │
└──────────────────────────────────┘

The dashboard is only the default overview.

Terminal Info provides many additional commands and plugins
for diagnostics, networking, system information, and developer tools.

Why I added a plugin system

While building the CLI, I realized that many terminal tools are limited by being fixed-feature applications.

For example:

system info tools
monitoring tools
diagnostics utilities

They are useful, but extending them often requires modifying the core codebase.

So I developed terminal-info CLI with a plugin system.

The idea is simple:

core CLI
+ plugin SDK
+ plugin registry

Developers can write plugins that extend the CLI without modifying the main repository.

Security considerations

One challenge with plugin systems is security.

To address this, the project includes:

signed plugin releases
integrity verification
registry review
local trust controls

Users must explicitly trust a plugin before it can run.

Project goals

The long-term goal is to turn terminal-info into a general-purpose CLI toolbox where new functionality can live as plugins.

Instead of replacing existing tools, the idea is to provide a platform where small terminal utilities can coexist and evolve.

Feedback welcome

The project is still early and I would really appreciate feedback from the community, especially on the plugin architecture and developer experience.

GitHub: https://github.com/T-1234567890/terminal-info
Docs: https://github.com/T-1234567890/terminal-info/tree/main/docs

The project is open source and licensed under Apache 2.0.