DEV Community: Samet Burgazoğlu

Introducing Atilgan: The Golang and GTK4 File Manager Built for Speed and Productivity

Samet Burgazoğlu — Tue, 25 Nov 2025 16:24:30 +0000

While there are many file managers available, finding one that perfectly balances lightweight performance with rich functionality is a challenge.

Atilgan is a file manager/browser written in Golang using the GTK4 toolkit. Designed strictly for Linux distributions, it helps to find your files faster.

The Philosophy: Productivity First

The primary purpose of Atilgan is to boost productivity. Traditional file navigation often involves a slow cycle: find a file, double-click to open an external app, wait for it to load, close it, and repeat.

Atilgan aims to break this cycle. Its goal is to help you find folders and identify files faster without the need to actually open them. By integrating a powerful viewer directly into the file manager, Atilgan keeps you in the flow.

The Previewer

At the heart of Atilgan is its robust preview capability. When you select a file and press Space, you get an instant look at the content. Here is how it handles different formats:

Text & Code: Simple text files are rendered using GtkTextView. For programming files, Atilgan utilizes GtkSourceView, providing rich syntax highlighting for code review.
Images: Leveraging GtkImage, it supports all image formats native to GTK4.
Multimedia: You can play music and watch videos directly inside the file manager using GtkVideo. (Note: For extensive format support, you may need extra packages like ubuntu-restricted-extras).
PDFs: Atilgan relies on pdftoppm (available on almost every Linux distro) to render fast PDF previews.
Documents: Office files (DOCX, XLSX, PPTX) are previewed using unoconv, allowing you to view documents without launching a heavy office suite.
Directories: Even folders have previews. When you select a folder, Atilgan uses a directory previewer to show you a glimpse of what is inside before you enter it.

A Custom-Built ListView

Atilgan does not rely on standard, classic list widgets. Instead, it features a custom list view implementation drawn directly to the drawing area using Cairo.

This custom engine allows for unique features:

Smart Grouping: You can group files alphabetically or by modification time.
Fast Navigation: Using the Shift key, you can jump between groups rapidly.
Rich Metadata: Every file displays a thumbnail and essential information at a glance.

Powerful Organization & Search

Finding what you need is paramount. Atilgan offers several tools to keep your digital life organized.

Filtering and Tags

Tags: You can tag specific files and folders, then quickly access them via the dedicated Tag section.
Smart Filters: Filter your view based on file abilities (e.g., executables, folders) or by specific extensions (e.g., .png, .docx, .mp4).

Search Under the Hood

File Search: Atilgan uses the native find command for blazing speed (with Regex support coming soon).
Content Search: To find text inside files, it combines grep and find for accurate results.

Streamlined User Experience

Atilgan includes several UI features designed for modern usage:

Unique Pathbar: Navigate effortlessly backward and forward. The pathbar also makes copying paths or jumping to specific locations seamless.
Recent Section: Atilgan tracks your interactions, storing your recently used folders and files so you can pick up exactly where you left off.
Sidebar: Quick access to standard User Directories, which are auto-detected using XDG specifications.

Compatibility

Atilgan is a Linux-first project. It is designed to integrate deeply with Linux distributions. Currently, there are no plans to port the application to Windows or macOS.

New PostgreSQL ORM for Golang: Enterprise

Samet Burgazoğlu — Fri, 20 Dec 2024 21:09:06 +0000

Why we need a new ORM?

There are actually a few good ORMs available, but they just didn't meet my needs. So what did I want?

High performance
Schema as code
Statically typed and generated api code
Less generated file
Simple and Functional
Easy RawSQL usage
Single db hit filter when join relation

At the moment I can't say enterprise do well all of the things I mentioned. But it aims to do so.

So let's look what enterprise do.

High Performance

You can see the benchmark source code here.
https://github.com/MrSametBurgazoglu/go-orm-benchmarks/tree/enterprise

As you can see enterprise is very well at performance.

Schema as code

Like many others enterprise generate db models from your code.
Here is a little example

// db_models/account.go
package db_models

import (
    "github.com/MrSametBurgazoglu/enterprise/models"
    "github.com/google/uuid"
)

func Account() *models.Table {
    idField := models.UUIDField("ID").DefaultFunc(uuid.New)

    tb := &models.Table{
        Fields: []models.FieldI{
            idField,
            models.StringField("Name"),
            models.StringField("Surname"),
            models.UUIDField("TestID").SetNillable(),
        },
        Relations: []*models.Relation{
            models.ManyToOne(TestName, idField.DBName, "test_id"),
            models.ManyToMany(GroupName, "account_id", "group_id", "id", AccountGroupName),
        },
    }

    tb.SetTableName(AccountName)
    tb.SetIDField(idField)

    return tb
}

// generate/generate.go
package main

import (
    "example/db_models"
    "github.com/MrSametBurgazoglu/enterprise/generate"
)

func main() {
    generate.Models(
        db_models.Test(),
        db_models.Account(),
        db_models.Group(),
    )
}

When you execute the script above it will create a package named models and put two file for each table named model.go and model_predicates.go . And there will be a client.go for using db.

Statically typed and generated api code

After auto-generate models you can create and get models.


import "/your/project/models" // your auto-generated models package

func main() {
    db, err := models.NewDB(dbUrl)
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    account := models.NewAccount(ctx, db)
    account.SetName("name")
    account.SetSurname("surname")
    err = account.Create()//row added to table
    if err != nil {
        log.Fatal(err)
    }
}


import "/your/project/models" // your auto-generated models package

func main() {
    db, err := models.NewDB(dbUrl)
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    account := models.NewAccount(ctx, db)
    account.Where(account.IsIDEqual(uuid.New()))
    err = account.Get()//row variables set to account struct
    if err != nil {
        log.Fatal(err)
    }
}

Less generated file

Like I said before enterprise generate 2 file for each table and one client file who uses all of them. It handles most cases in own package this way you will have more clean structure.

Simple and Functional

Enterprise aims simple and fuctional interaction with db fields. For this, fields have helper functions.

Let's say you have a nillable uuid named face_id on table and you represent it with *uuid. Enterprise will generate a helper function to set it with string. That way you don't need to get pointer of that variable.

func (t *Account) SetFaceIDValue(v uuid.UUID)

If you have a uuid field it will create a parser helper.

func (t *Account) ParseFaceID(v string) error

For some value types it will have IN clause.

func (t *Account) FaceIDIN(v ...uuid.UUID) bool
func (t *Account) FaceIDNotIN(v ...uuid.UUID) bool

For time.Time it will create these helper functions.

func (t *Account) FormatCreatedAt(v string) string
func (t *Account) ParseCreatedAt(layout, value string) error

Easy RawSQL Usage

Enterprise can create complex queries but need for RawSQL always will be. Because of that you can use models.IDatabase to interact with pgx. We have plans to scan raw sql result to your db models or custom structs you create with relation if need.

Single db hit filter when join relation

One of the most important features that separates Enterprise from others is can join relations and filter them with single query.

One example is like this. Let's get a student's wrong answered test questions where test score higher than 80.

s := models.NewStudent(ctx, db)
s.Where(s.IsIDEqual(studentID))
s.WithTestList(func(testList *models.TestList) {
    testList.Where(
        testList.IsPointGreaterThan(80),
    )
    testList.Order(models.CreatedAtField)
    testList.WithQuestionList(func(questionList *models.QuestionList){
            questionList.Where(
                questionList.IsAnswerEqual(False),
            )
    })
})
err = s.Get()//row variables set to model and its relations struct.
if err != nil {
   log.Fatal(err)
}

For repository: https://github.com/MrSametBurgazoglu/enterprise
For documentation: https://mrsametburgazoglu.github.io/enterprise_docs/