I’m Building a Linux Distribution in Kosovo — Here’s What I’ve Learned

elionbardhiii-hub — Fri, 18 Sep 2026 13:53:34 +0000

What if you could build your own Linux distribution from scratch and shape the entire desktop experience around the people you want to help?

That question led me to start DardanOS, a Linux distribution being developed in Kosovo.

It started as a personal project, but over time it became much more ambitious: a beginner-friendly Linux desktop with its own applications, its own ecosystem, and an integrated AI assistant called DardanAI.

DardanOS is currently preparing for its 1.0 release, which is planned for October 2026.

This is the story of what I have learned while building it.

Why build another Linux distribution?

There are already hundreds of Linux distributions.

So the obvious question is:

Why create another one?

For me, the answer isn't about trying to replace Ubuntu, Debian, Fedora, Arch, or any other established distribution.

I wanted to experiment.

I wanted to understand what actually happens when you take a Linux base and turn it into a complete operating-system experience.

I also wanted to build something that could feel approachable to people who have never used Linux before.

That became the main idea behind DardanOS:

Make Linux feel less intimidating without taking away the freedom that makes Linux special.

The project started much smaller

DardanOS didn't begin as a polished operating system.

I experimented with different Linux environments and approaches before settling on the current direction.

I tried different desktop environments, different bases, virtual machines, customizations, and build approaches.

Some experiments worked.

Others completely failed.

And honestly, those failures taught me some of the most useful lessons.

One of the biggest lessons was that creating a Linux distribution isn't simply changing wallpapers, icons, and themes.

A distribution is an ecosystem.

You have to think about:

The base system
Packages
Desktop environment
Applications
Installer
Updates
Hardware compatibility
User experience
Documentation
Security
Community
Distribution of the ISO

Every part affects the others.

Building with Cubic

For the current DardanOS 1.0 development process, I'm using Cubic as part of the ISO customization workflow.

This made experimenting with the system significantly easier.

Instead of rebuilding everything from zero, I can work inside a customized Linux filesystem, install packages, add applications, modify configuration files, and prepare the resulting ISO.

The workflow looks roughly like this:

Linux base
    ↓
Cubic environment
    ↓
System configuration
    ↓
DardanOS applications
    ↓
Desktop customization
    ↓
Testing
    ↓
ISO

Inside the customized system, DardanOS applications are organized under:

/opt/dardanos/apps/

The current application structure includes components such as:

dardan-ai
dardan-settings
dardan-store
dardan-updater
dardan-about
dardan-core

This separation also makes it easier to develop the DardanOS ecosystem independently from the underlying Linux packages.

DardanAI

The part of DardanOS that I'm most interested in experimenting with is DardanAI.

The idea is to have an assistant integrated into the operating system rather than requiring the user to constantly search the web for Linux commands.

For example, a beginner could eventually ask:

"How do I install Firefox?"

or:

"Why isn't this application opening?"

or:

"Show me the applications installed on my computer."

Instead of expecting the user to understand package managers, terminal commands, dependencies, or configuration files, DardanAI is intended to translate the user's request into something the operating system can actually do.

The current prototype already has functionality for discovering applications and interacting with DardanOS components.

The longer-term goal is to expand this into a more complete operating-system assistant.

Application discovery

One surprisingly important problem was simply knowing what applications exist on the system.

DardanAI needs an understanding of the environment it is operating in.

For example, the assistant needs to distinguish between:

Dardan applications
System applications
Installed third-party applications
Utilities

That led me to create an application-discovery component.

It can inspect the desktop environment and identify available applications instead of relying entirely on a hardcoded list.

This is a small feature, but it becomes important when you start thinking about an AI assistant as part of an operating system.

Error fixing

Another part of DardanAI is an experimental error-fixing system.

The idea is simple:

User encounters problem
        ↓
DardanAI analyzes the problem
        ↓
Possible cause is identified
        ↓
Possible solution is suggested
        ↓
User can choose what to do

One important lesson here is that an AI assistant shouldn't blindly execute commands.

A desktop assistant has access to the user's system, so safety and user control matter.

The goal is therefore not:

"AI does everything automatically."

The goal is closer to:

"AI explains what is happening and helps the user fix it."

Creating the DardanOS desktop

The current DardanOS direction uses GNOME as the desktop environment.

I wanted the interface to have a recognizable identity without making Linux feel unfamiliar.

The visual direction is based around:

Dark blue
Black
White
Simple layouts
Minimal visual clutter
Clear navigation
Beginner-friendly controls

The important part isn't simply making the desktop look different.

It is making the interface feel consistent.

That means applications such as:

Dardan Settings
Dardan Store
Dardan Updater
Dardan About
DardanAI

should eventually feel like parts of the same operating system rather than unrelated applications.

The hardest part: everything is connected

One thing I underestimated was how interconnected an operating system project becomes.

Changing one thing can affect something completely different.

For example:

Application
   ↓
Desktop entry
   ↓
Application discovery
   ↓
DardanAI
   ↓
Permissions
   ↓
System packages

A problem in one layer can appear as a completely different problem somewhere else.

This forced me to become much more comfortable with debugging Linux systems.

I've learned to inspect logs, check files, verify package availability, test commands independently, and avoid assuming that the first error message tells the whole story.

Testing is a huge part of the project

A working build doesn't necessarily mean you have a working operating system.

There is a big difference between:

"It boots on my computer."

and:

"Other people can install and use it."

That's why testing has become one of the most important parts of the DardanOS 1.0 process.

The current build is being tested for:

Booting
Application launching
Desktop functionality
DardanAI
System settings
Updates
Installer workflow
Hardware compatibility
General usability

The goal is to find problems before the final release.

What I've learned about Linux development

Building DardanOS has taught me several things that I probably wouldn't have learned by only using Linux.

1. Linux is much more than the desktop

When you use a Linux distribution every day, it's easy to think mainly about the desktop environment.

Building one makes you see the layers underneath it.

There are packages, services, permissions, configuration files, kernels, boot processes, display servers, desktop components, installers, and much more.

2. Debugging is a skill

Sometimes the solution isn't complicated.

The difficult part is discovering what is actually broken.

I've learned to avoid immediately changing five things at once.

Instead:

Observe
↓
Reproduce
↓
Identify
↓
Change one thing
↓
Test again

This has saved me from creating even bigger problems.

3. Small tools can become important

A small component like application discovery might not sound exciting.

But when you connect it to an AI assistant, desktop launcher, settings application, and software store, it becomes part of a larger architecture.

That changed how I think about software development.

A feature doesn't always need to be huge.

It needs to fit into the system.

4. Building in public is valuable

DardanOS has also taught me that development isn't only about code.

Sharing progress allows other developers to see the project, provide feedback, identify problems, and potentially become contributors or testers.

The project is being developed openly because I want other people to be able to follow the journey.

What's next?

The immediate goal is DardanOS 1.0.

The current build is in testing, with the final release planned for October 2026.

After that, I want to continue developing the ecosystem around the operating system.

Some of the areas I'm interested in include:

Improving DardanAI
Expanding DardanStore
Better system management tools
More hardware testing
Better documentation
Community contributions
More applications
Installer improvements
Potential ARM experimentation

There is still a lot to build.

Why Kosovo?

DardanOS is being developed in Kosovo.

For me, that's an important part of the project.

There are talented developers and technology communities in Kosovo, but projects don't always get visibility outside the region.

I wanted to create something that could be both technically interesting and represent where it came from.

DardanOS isn't trying to claim that Kosovo invented Linux.

It is simply an example of a software project being built here.

And hopefully it can encourage more people in the region to experiment with open-source software.

The road ahead

DardanOS is still a young project.

There will be bugs.

There will be things that need to be redesigned.

There will probably be features that I eventually remove completely.

That's part of building software.

The important thing for me is continuing to learn and improve the project.

Right now, the milestone is simple:

DardanOS
   ↓
1.0 Testing
   ↓
Final Release
   ↓
Community
   ↓
More Development

I'm especially interested in hearing from Linux developers and users.

If you've built a Linux distribution before, worked with Cubic, developed desktop applications, or experimented with Linux system automation, I'd love to hear what you learned from your experience.

Follow the project

🌐 Website: https://dardanos-website.elion-bardhiii.workers.dev

💻 GitHub: https://github.com/elionbardhiii-hub/dardanos-website

📧 Email: elion.bardhiii@gmail.com

If you're interested in Linux, open source, operating-system development, or AI-powered desktop tools, feel free to follow the project and share your thoughts.

This is only the beginning.

DardanOS 1.0 is coming. 🇽🇰

DEV Community: elionbardhiii-hub

I’m Building a Linux Distribution in Kosovo — Here’s What I’ve Learned

Why build another Linux distribution?

The project started much smaller

Building with Cubic

DardanAI

Application discovery

Error fixing

Creating the DardanOS desktop

The hardest part: everything is connected

Testing is a huge part of the project

What I've learned about Linux development

1. Linux is much more than the desktop

2. Debugging is a skill

3. Small tools can become important

4. Building in public is valuable

What's next?

Why Kosovo?

The road ahead

Follow the project