Why I'm Porting GNU Coreutils to Python (And How You Can Help!)

Junaid Rahman — Wed, 30 Jul 2025 11:34:17 +0000

Building PY-CoreUtils: The Modern, Cross-Platform Python Port of GNU Coreutils

Unix CLI Power Meets Pythonic Flexibility

Ever wished you could use familiar Unix commands like rm, mkdir, and date anywhere Python runs? What if I told you that you could have all the power of GNU coreutils without needing a C toolchain, makefiles, or platform-specific binaries?

That's exactly what PY-CoreUtils delivers: ✨ Unix CLI power with Pythonic flexibility.

The Vision Behind PY-CoreUtils

When I started this project, I had a simple but ambitious goal: create a modern, cross-platform Python port of the essential GNU coreutils that developers rely on every day. Here's what makes PY-CoreUtils special:

🖥️ True Cross-Platform Support

Works seamlessly on Linux, macOS, and Windows — no C toolchain needed. Just Python.

🧩 Drop-in CLI Compatibility

Familiar commands, same flags, same output. If you know GNU coreutils, you already know how to use PY-CoreUtils.

🐍 Pure Python Implementation

No dependencies, hackable, readable, and infinitely extendable. Perfect for learning and customization.

💡 Perfect for Modern Development

Great for scripting, teaching, development environments, and anywhere you need reliable CLI tools.

🔥 Modern Code, Modern Vibes

Built with contemporary Python practices, full test coverage, and CI/CD integration.

⚡ Nuitka: The Secret Weapon

Here's where it gets really interesting: Python + Nuitka = Native Performance. Nuitka compiles Python to optimized C++, giving us the best of both worlds — Python's expressiveness during development and C-like performance in production.

What's Already Working

The project has solid foundations with several core utilities already implemented:

✅ Completed Tools

basename - Extract filename from path
date - Display/format dates with full GNU compatibility
echo - Display text with escape sequence support
mkdir - Create directories with -p recursive support
pwd - Print working directory with logical/physical path handling
rm - Remove files/directories with interactive, force, and recursive modes
touch - Create/update file timestamps
whoami - Display current username
nproc - Show number of processing units

Want to try them right now? It's literally this simple:

git clone https://github.com/Junaid433/PY-CoreUtils.git
cd PY-CoreUtils
python src/mkdir.py --help
python src/rm.py --help
python src/date.py --help

The Nuitka Advantage: Best of Both Worlds

Here's the game-changing insight that makes PY-CoreUtils truly special: Why port to Python when we could just use C? The answer is Nuitka.

🚀 Development in Python, Performance in C++

Traditional coreutils are written in C, which means:

Complex build systems and toolchains
Platform-specific compilation challenges
Memory management headaches
Difficult debugging and testing
High barrier to entry for contributors

With Python + Nuitka, we get:

🧩 Easier Maintenance

# Python: Clean, readable, maintainable
def remove_file(path, force=False, interactive=False):
    if interactive and not confirm_deletion(path):
        return
    try:
        path.unlink()
    except OSError as e:
        if not force:
            raise RemovalError(f"Cannot remove {path}: {e}")

# vs C: Complex error handling, manual memory management
// Hundreds of lines of malloc/free, error checking, etc.

⚡ Near-Native Performance

Nuitka compiles Python to optimized C++, delivering performance that rivals traditional C implementations while maintaining Python's simplicity.

🔧 Rapid Feature Development

Need to add JSON output to ls? Unicode support to sort? Regular expressions to grep? In Python, these are one-liner imports. In C, they're massive undertakings.

🌐 True Cross-Platform Deployment

Nuitka produces standalone executables for Windows, macOS, and Linux from the same Python source code. No more separate build systems per platform.

🧪 Modern Development Workflow

# Development: Fast iteration with Python
python src/ls.py --long --human-readable

# Testing: Rich Python ecosystem
pytest tests/ --coverage --parallel

# Production: Compile to native executable
nuitka --standalone --onefile src/ls.py
# Result: Fast, portable binary with no Python dependency

This is revolutionary: Write once in Python, compile everywhere with native performance.

The Technical Excellence

Building on the Nuitka foundation, each utility is implemented with serious attention to detail:

🎯 Full GNU-Style CLI

Every tool supports the major flags, proper help/version output, and correct exit codes you'd expect from the originals.

🔗 Smart Path Handling

Tools like pwd support both logical (-L) and physical (-P) paths, handle symlinks correctly, and respect POSIXLY_CORRECT environment variables.

⏰ Advanced Date/Time Operations

The date implementation supports parsing, formatting, reference files, UTC conversion, batch processing, and more — matching GNU date's full feature set.

🛡️ Safe & Robust Operations

rm includes interactive prompts, force modes, and recursive deletion with proper safety checks.

✅ Quality Assurance

100% pytest coverage and GitHub Actions CI ensure reliability across platforms.

The Massive Opportunity Ahead

Here's where it gets exciting — we've completed less than 10% of the full GNU coreutils suite! The roadmap includes 80+ more utilities:

🔥 High-Priority Targets

cat, ls, cp, mv - The everyday essentials
head, tail, wc - Text processing workhorses
chmod, chown, stat - File permission/metadata tools
grep, sort, uniq - Text filtering and sorting
find, xargs - File discovery and batch operations

📊 Current Status

✅ 9 utilities complete
⏳ 80+ utilities planned
🎯 ~10% completion — tons of opportunity!

How You Can Make a Massive Impact

This project needs contributors, and there are opportunities for developers of all skill levels:

🚀 For Beginners

Perfect first contributions:

true/false - Simple exit code utilities
yes - Infinite text output (great for learning CLI parsing)
basename/dirname - Path manipulation utilities
Documentation - Usage examples, tutorials, migration guides

🔮 Future-Proof Architecture

The Python + Nuitka approach means we can easily integrate:

Async operations for handling massive file sets
Rich terminal output with colors and formatting
JSON/YAML output modes for modern scripting
Plugin systems for extensibility
Machine learning integration for intelligent file operations
Cloud storage backends for remote operations

Try adding any of these features to traditional C coreutils — it's a nightmare. In Python, they're natural extensions.

💻 For Intermediate Developers

Substantial utilities to tackle:

cat - File concatenation with multiple options
wc - Word/line/character counting
head/tail - File beginning/end extraction
sleep - Timing and delay utilities

🧠 For Advanced Contributors

Complex, high-impact utilities:

ls - Directory listing with sorting, formatting, colors
grep - Pattern matching with regex support
sort - External sorting algorithms for large files
find - Recursive file discovery with complex predicates

🏗️ Infrastructure & Tools

Performance benchmarking frameworks
Windows-specific optimizations
Enhanced testing infrastructure
Documentation and tutorial creation

Getting Started is Easy

Ready to contribute? Here's your path to making an impact:

# 1. Fork and clone
git clone https://github.com/Junaid433/PY-CoreUtils.git
cd PY-CoreUtils

# 2. Explore existing implementations
python src/date.py --help
python src/rm.py -rf build/
python src/mkdir.py -p test/nested/dirs

# 3. Pick an unimplemented utility from the roadmap
# 4. Study the existing code patterns
# 5. Implement, test, and submit a PR!

Why This Matters

PY-CoreUtils + Nuitka isn't just another open source project — it's infrastructure for the future:

🎓 Educational Impact

Perfect for teaching systems programming, CLI design, and Python best practices. Students can read and understand every line of code, then see it compile to native performance.

🔧 Development Productivity

Scriptable, cross-platform CLI tools that work identically everywhere Python runs, but compile to fast native executables when needed. No more "works on my machine" issues.

🌍 Accessibility

Bringing powerful Unix tools to Windows developers and anyone who can't or won't install GNU coreutils — with native performance.

🚀 Innovation Platform

A foundation for building modern CLI tools with Python's rich ecosystem — imagine coreutils with built-in JSON output, async operations, or machine learning integration, all compiled to native speed.

Join the Revolution

We're building something that could benefit millions of developers worldwide. Every utility you implement, every bug you fix, every test you write brings us closer to a complete, reliable, modern implementation of the tools that power our digital world.

The GNU coreutils took decades to perfect. With Python, Nuitka, and a passionate community, we can build something even better — more maintainable, more extensible, and just as fast.

Ready to Contribute?

🌟 Star the repo: github.com/Junaid433/PY-CoreUtils
🐛 Check issues: Find your first contribution
💬 Join discussions: Share ideas and get help
📢 Spread the word: Help us find more contributors

💡 Hack, learn, and build with Python-powered coreutils!

Tags: #python #opensource #cli #coreutils #crossplatform #gnu #unix #scripting #devtools

ImportLess – Trim unused Python dependencies with a single command

Junaid Rahman — Mon, 21 Jul 2025 09:49:08 +0000

🚀 ImportLess – Detect the Python dependencies you actually use

Ever looked at a requirements.txt and thought:

"Do I really use all of these packages?"

You're not alone. Most tools like pip freeze include everything installed in your environment, not just what your project imports. This leads to:

❌ Bloated requirements
🐢 Slower deployments
🔐 Higher security risk surface

🧰 Meet ImportLess

ImportLess is a reverse dependency scanner that walks your codebase and builds a minimal list of actually used packages.

pip install importless

importless scan
importless export

DEV Community: Junaid Rahman