We've been making some significant decisions behind the scenes at Snigdha OS. And this time, we're not simply updating a desktop environment, changing wallpapers, or introducing another collection of packages.
We're rethinking how Snigdha OS is built.
The next edition of our distribution will be called Snigdha OS Eclipse.
Eclipse represents a new chapter for the project. Alongside the new edition, we're working on changes to the underlying architecture, package infrastructure, recovery capabilities, system automation, and first-party tooling.
Here's what we're currently working on.
1. Introducing Snigdha OS Eclipse
A new identity, with a stronger foundation behind it.
Snigdha OS Eclipse is the new edition we're working toward.
However, we don't want this to be just a rebranding exercise. The intention is to use this opportunity to rethink several parts of the distribution and build a more cohesive experience.
Our priorities are straightforward:
- A clean and maintainable Arch Linux foundation.
- A carefully composed installation image.
- Better integration between system components.
- First-party utilities that serve an actual purpose.
- Less unnecessary complexity.
We want the distribution to feel intentional rather than assembled from an endless collection of components.
2. Rebuilding the Snigdha OS Core
One of our biggest focuses right now is the core system and ISO.
We've been reviewing how other successful Arch-based distributions structure their installation images and underlying system components.
One thing became clear: we were making parts of the system more complicated than necessary.
We don't want an ISO that tries to do everything.
Instead, we're taking a more practical approach:
- Keep the base system lean.
- Include only what is necessary for the intended installation experience.
- Avoid unnecessary services and dependencies.
- Keep system configuration understandable.
- Make the build process easier to maintain and reproduce.
The objective is not to build the biggest ISO. It's to build an ISO that provides a solid foundation without unnecessary baggage.
3. A New Package Repository Infrastructure
We're also changing how we distribute Snigdha OS packages.
Previously, we considered Cloudflare R2 for package storage. We've decided to move away from that approach.
Our current direction is to use GitLab Pages as our package repository infrastructure.
This brings our package distribution closer to the GitLab-based development workflow we're already using.
The focus is on making package publishing and repository maintenance simpler, with CI/CD playing an important role in the process.
Repository:
https://gitlab.com/snigdhaos/repos/repos
This is an infrastructure decision, but it's an important one. Package distribution should be straightforward to maintain instead of introducing additional infrastructure that we don't actually need.
4. Building Snigdha OS Rescue
System recovery deserves more attention than it usually receives in Linux distributions.
That's why we're putting dedicated effort into Snigdha OS Rescue.
Rather than treating recovery as an afterthought, we're developing it as a focused part of the Snigdha OS ecosystem.
The goal is to provide a dedicated environment for troubleshooting and recovering Linux installations.
We're approaching this as its own project, with attention to simplicity, reliability, and practical recovery workflows.
A recovery environment should be useful when things go wrong, not another complicated application that introduces more problems.
5. Introducing snigdhaos-hooks
Another important part of our current development is our own system hooks implementation:
snigdhaos-hooks
We have been looking at existing Linux distribution implementations, including Garuda Linux's hooks:
https://gitlab.com/garuda-linux/pkgbuilds/-/tree/main/garuda-hooks
That gives us useful inspiration, but we want something designed around Snigdha OS itself.
The idea is to provide a controlled mechanism for system-level automation and integration.
This will help us manage distribution-specific operations without scattering custom scripts and workarounds throughout the system.
We want the implementation to be predictable, maintainable, and easy for developers to understand.
6. Rethinking First-Party Applications
We're also reconsidering how we build and distribute desktop utilities.
For applications that need a desktop interface, we're adopting Tauri as part of our development direction.
The goal is to build focused applications without unnecessarily introducing heavy application stacks.
We want our first-party tools to integrate naturally with the operating system while remaining independently maintainable.
The broader philosophy is simple: build dedicated tools for real problems instead of creating software just to increase the number of applications shipped with the distribution.
7. Less Overengineering, More Engineering
This is probably the most important change in our approach.
We have realised that building a Linux distribution is not about adding as many custom components as possible.
Every additional component introduces maintenance responsibilities, dependencies, potential failure points, and long-term complexity.
We want to be much more selective.
When an existing Arch Linux component does the job properly, there is little reason to reinvent it. When Snigdha OS needs something specific, we want to build it properly and maintain it ourselves.
That distinction will guide the Eclipse development direction.
What's Next?
Our current development priorities revolve around bringing these pieces together:
- Establishing a clean and maintainable Snigdha OS Core.
- Simplifying and validating the ISO build process.
- Establishing the GitLab Pages-based package repository.
- Continuing development of Snigdha OS Rescue.
- Developing and integrating
snigdhaos-hooks. - Improving our first-party application ecosystem.
- Bringing everything together into a consistent Snigdha OS Eclipse experience.
These are active development workstreams, not a declaration that everything is already finished. We would rather get the foundations right than rush out a release with unfinished components.
We Want to Build This in the Open
Snigdha OS is an open-source project, and we want the development process to reflect that.
We're interested in feedback from Arch Linux users, Linux developers, distribution maintainers, and anyone who enjoys understanding how operating systems are built.
Whether it's ISO architecture, package management, system hooks, recovery workflows, or desktop tooling, constructive feedback is welcome.
Snigdha OS Eclipse is more than a new edition name. It's an opportunity to build Snigdha OS with a clearer direction, simpler architecture, and a stronger foundation.
We're getting back to the fundamentals.
And we're just getting started. 🌘
Project: Snigdha OS
New Edition: Snigdha OS Eclipse
Website: https://snigdhaos.org/
Package Repository: https://gitlab.com/snigdhaos/repos/repos
Built with the open-source community in mind.
Top comments (1)
🔥🔥