DEV Community: Md. Mahmudul Hasan Mabud

Installing SysLens: A Lightweight Linux System Information Tool

Md. Mahmudul Hasan Mabud — Mon, 09 Mar 2026 18:57:53 +0000

If you are a Linux enthusiast or a developer, you know the importance of quickly checking your system’s health, hardware specifications, and resource usage. SysLens is a lightweight, terminal-based tool written in C that provides a real-time snapshot of your system by reading the Linux /proc filesystem.

In this guide, I’ll walk you through installing SysLens on your Linux machine, compiling it from source, and optionally installing it system-wide.

Prerequisites

Before you start, make sure you have:

A Linux-based operating system (Ubuntu, Debian, Fedora, Arch, etc.)

gcc or clang compiler installed

make utility

Basic terminal knowledge

Step 1: Clone the Repository

First, clone the SysLens GitHub repository to your local machine:

git clone https://github.com/mahmudul626/syslens.git
cd syslens

Step 2: Build from Source

SysLens uses a simple Makefile for compilation. To build the project:

make

If successful, this will create an executable named syslens in the project directory.

Step 3: Run SysLens

Run the tool directly from the terminal:

./syslens

You’ll see three sections:

System Info: OS name, kernel version, CPU model, uptime, and current user.
Resource Usage: RAM, swap usage, and load averages with visual progress bars.
Active Processes: Total tasks, running, sleeping, and zombie processes.

You can also use flags to display specific sections:

./syslens -s # System info only
./syslens -m # Resource usage only
./syslens -p # Active processes only
./syslens --version
./syslens --help

Step 4: Optional System-wide Installation

To make SysLens accessible from anywhere on your system:

sudo make install

This will copy the executable to /usr/bin/syslens. Now you can simply run:

syslens

To uninstall:

sudo make uninstall

Step 5: Testing & Validation

SysLens has been designed to work on multiple Linux distributions. You can validate its performance using tools like:

valgrind – for memory leak detection

cppcheck – for static code analysis

These are already integrated in the CI/CD workflow if you are contributing or compiling from the source.

Conclusion

SysLens is a lightweight, fast, and reliable Linux CLI tool to monitor your system. Whether you are a developer, sysadmin, or hobbyist, it provides an instant overview of your system’s health and performance.

Try it out, contribute, or suggest improvements on GitHub.

From Curiosity to Code: How I Built SysLens, a Linux CLI System Monitor

Md. Mahmudul Hasan Mabud — Mon, 09 Mar 2026 18:01:07 +0000

Ever wondered what’s really happening inside your Linux system? The tools you use every day—top, htop, neofetch—give you the numbers, but do you know how they actually work under the hood?

I didn’t—so I decided to build my own. Enter SysLens: a lightweight, fast, and simple CLI system monitor written entirely in C.

Why Another System Monitor?

There are dozens of Linux tools already. Why make one more?

For me, it was all about learning by doing. Every new project is a skill test, and building something from scratch forces you to explore details you’d otherwise take for granted. With SysLens, I wanted to:

Understand the Linux /proc filesystem deeply
Parse and display system stats efficiently in C
Learn to build a professional, modular CLI tool

Meet SysLens

SysLens gives you essential system information in a clean, readable format:

[ System Info ]
OS : Ubuntu 22.04 | Kernel : 6.8.0
CPU : Intel(R) Core(TM) i5
Uptime : 27 mins | User : mahmudul

[ Resource Usage ]
RAM : [###.......] 34% (2.7GiB/7.6GiB)
Swap : [..........] 0%
Load avg : 1.40, 1.17, 0.78

[ Active Processes ]
Task : 231 total | 2 running | 229 sleeping | 0 zombie

No clutter. No fluff. Just real-time, critical system info at a glance.

Core Features

System Overview: OS, Kernel, CPU, uptime, current user

Resource Monitoring: RAM, swap, load averages with color-coded bars

Process Stats: Total, running, sleeping, and zombie processes

CLI Flags: -s, -m, -p, --help, --version

Lightweight & Fast: Minimal memory footprint, no external dependencies

How SysLens Works

SysLens reads directly from Linux’s virtual /proc filesystem:

/proc/cpuinfo → CPU model

/proc/meminfo → RAM and swap usage

/proc/loadavg → system load averages

/proc/uptime → uptime

/proc/[PID]/status → process states

By parsing these files safely and efficiently, it outputs everything you need without unnecessary overhead.

Code Structure

I kept the code modular to maintain readability and scalability:

syslens/
├── include/main.h # Headers & macros
├── src/main.c # CLI & orchestrator
├── src/sys.c # OS & CPU info
├── src/mem.c # Memory & load logic
├── src/proc.c # Process parsing
├── Makefile
└── README.md

Every module handles a single responsibility—classic separation-of-concerns in action.

Lessons Learned

Building SysLens taught me more about Linux internals than I could have imagined:

How virtual filesystems expose kernel data

How to parse system stats safely and efficiently

How to design CLI tools with modular C code

The importance of readable, maintainable code

Most importantly:

The best way to learn a tool is to build it yourself.

Future Plans

Real-time CPU usage bars

Disk and network monitoring

Improved terminal UI

Automated builds and CI/CD pipeline for multi-platform releases

Try SysLens Yourself

GitHub: https://github.com/mahmudul626/syslens
Portfolio: https://mahmudul.pro.bd

Just clone, make, and run:

git clone https://github.com/mahmudul626/syslens.git
cd syslens
make
./syslens

Final Thoughts

SysLens started as a curiosity experiment, but now it’s a full-fledged CLI tool.

If you’re a Linux developer or C programmer, I challenge you to build one of the tools you use every day. It’s an incredible way to level up your skills and truly understand your system.

What is syslens and why i built this?

Md. Mahmudul Hasan Mabud — Wed, 18 Feb 2026 08:02:41 +0000

Syslens is a Linux CLI tool that displays system information in a clean, colorful format.
Currently, it only works with a few Linux distributions. It isn't quite mature enough to support all of them yet because some elements are still hardcoded. However, distributions like Ubuntu work perfectly and run clearly without crashing.

While tools like Neofetch exist, I built syslens from scratch in C to understand how Linux exposes system metrics via the kernel.

Building from Scratch: Introducing Syslens, a Linux System Info Tool

Md. Mahmudul Hasan Mabud — Tue, 17 Feb 2026 18:27:27 +0000

In the world of Linux, there are plenty of great tools for fetching system information. So, why build another one? For me, the answer is simple: I wanted to see if I could.
I’ve always been curious about how these tools work under the hood. To me, every project is a skill test—a way to challenge myself and create something that is uniquely mine. Syslens is the result of that curiosity.
What is Syslens?
Syslens is a lightweight, CLI-based tool designed to display your essential Linux system information in a clean, colorful, and easy-to-read format. No clutter, just the data you need.
Key Features
Clean UI: Simple, organized layout using standard terminal colors.
Essential Stats: Quickly view your OS version, Kernel, CPU details, RAM usage, and Uptime.
Lightweight: Built with efficiency in mind, written in C.
Final Thoughts
Building Syslens was a great exercise in interacting with the Linux filesystem and handling system calls. If you're a developer, I highly recommend building your own version of the tools you use every day—it's the best way to level up.
🔗 Let's Connect!
View the Code on GitHub: https://github.com/mahmudul626/syslens
Check out my Portfolio: https://mahmudul.pro.bd

Turning a Simple Number Guessing Game into a Professional C Project

Md. Mahmudul Hasan Mabud — Sun, 15 Feb 2026 08:37:01 +0000

When I first wrote a Number Guessing Game in C, it was a small, personal project—just a few lines of code to practice loops, conditionals, and basic input/output. But as I delved deeper into development, I realized that even a beginner project could be transformed into a professional, maintainable, and scalable system with the right approach.
Modular Architecture
The first step was restructuring the code. Instead of keeping all logic in a single file, I separated the project into:
include/ – all header files defining function prototypes and data structures.
src/ – implementation of core modules like game logic, file management, and leaderboard.
data/ – persistent storage for player statistics.
main.c – the central entry point coordinating game flow.
This modular design ensures that each component is independent, easy to debug, and ready for future extensions.
Persistent Data Management
Tracking wins, losses, and player statistics adds depth to a simple game. I implemented a robust file management system that reads from and writes to a dedicated storage file. This separation of game logic from storage operations not only keeps the code clean but also enables potential upgrades, like database integration or cloud synchronization.
Dynamic Leaderboard
A game feels more engaging when players can compete. The leaderboard module sorts players dynamically based on their performance, illustrating how algorithms can be integrated smoothly into a modular project without entangling the main game flow.
Build Automation with Makefile
Professional C projects rely on build automation. I created a Makefile that compiles and links multiple source files, manages build flags consistently, and provides a clean target to reset the workspace. This approach reduces errors, saves time, and mirrors real-world development practices.
Lessons from Taking a Small Project Seriously
Clean architecture matters: Modularization enables maintainability.
Automation is key: Makefiles or similar tools simplify repetitive tasks.
Separation of concerns: Keeping game logic independent of storage or UI allows scalability.
Future-ready design: Independent modules can be extended with new features without breaking the system.
Conclusion
Even a simple Number Guessing Game can be more than just a beginner exercise. By applying professional standards—modular design, persistent storage, automated build processes, and dynamic algorithms—I transformed a small project into a showcase of maintainable, scalable C programming. This experience reinforced a key lesson: taking any project seriously, no matter how small, is the first step toward professional software development.

Github repo- https://github.com/mahmudul626/number-guessing-game

Portfolio -https://mahmudul.pro.bd

[Boost]

Md. Mahmudul Hasan Mabud — Mon, 09 Feb 2026 18:08:41 +0000

Beyond Syntax: Why I Built My Own Unix-like Shell in C

Md. Mahmudul Hasan Mabud ・ Feb 8

#c #cli #linux #bash

Beyond Syntax: Why I Built My Own Unix-like Shell in C

Md. Mahmudul Hasan Mabud — Sun, 08 Feb 2026 16:34:59 +0000

For a long time, my world of C programming revolved around HackerRank challenges, nested loops, and problem-solving. After earning my 4th star and building a few mini-projects, I hit a wall. I asked myself: "Okay, I know C—but what can I actually build that breathes life into a system?"

That curiosity led me to look under the hood of Linux. I knew that the core of these massive operating systems was written in C. Suddenly, my mind was flooded with "Hows":

How does a simple command typed in a terminal transform into a running process?

How does the system handle signals like Ctrl+C without crashing?

What really happens behind the scenes of process management and command history?

Instead of just reading documentation, I decided to dive into the deep end: I started building my own Unix-like Shell from scratch.

Through this project, I realized that C isn't just a programming language; it’s a direct bridge to the heart of the operating system. In this series, I’m excited to share my journey of turning curiosity into code and building a functional shell, one system call at a time.

What was your first project that made you fall in love with system-level programming?