A self-hosted dnf package repository — aarch64 only, for now.

One repo, added with one command. It's fast wherever you're pulling from, and it costs you nothing to use.

shell
❯ sudo dnf install https://package.jelius.dev/setup-kazuma.rpm
  • aarch64 supported
  • amd64 not yet

A note on AI use

This was my first time packaging anything for dnf/rpm, and I leaned on AI in two very different places while building it. I used Gemini 3.1 Pro to help me understand compiler errors and the inner workings of the rpm toolchain — reading unfamiliar error output, and untangling environment variables the toolchain injects automatically that I had little prior insight into, given this was genuinely new territory for me. Separately, I used Claude (Anthropic's Sonnet 5) to help build the frontend for this site — the part you're reading right now. That one isn't mission-critical to anything; frankly, it doesn't matter which tool built a marketing page.

The packaging side is the part worth being precise about. AI was used as an interpreter, not an author — explaining what a cross-compiler error actually meant, or why a specific environment variable clash was breaking a build, across several different languages' toolchains. Every fix that came out of that was something I reviewed and applied myself; none of it was vibe-coded or accepted wholesale. Commit messages in this repo don't carry an AI-assisted trailer, because the actual solutions were mine, not generated code dropped in verbatim — closer to working with a knowledgeable companion than delegating the work. This is also a personal repository with no enforced sign-off policy, so there's no stance being taken here either way beyond describing what actually happened.

How the packages are actually built

The toolchain differs by language, since each one handles cross-compilation differently.

Rust

Rust builds go through LLVM and clang. Since everything targets aarch64 from an amd64 host, the build first needs an aarch64 sysroot with the right development libraries installed into it — for a GTK/libadwaita app, that install command looks something like this:

example
❯ dnf install --installroot=/opt/aarch64-sysroot --releasever=$(rpm -E %fedora) --forcearch=aarch64 --use-host-config -y \
    system-release \
    pkgconfig\(gtk4\) \
    pkgconfig\(libadwaita-1\) \
    pkgconfig\(epoxy\) \
    pkgconfig\(fontconfig\) \
    pkgconfig\(pangocairo\) \
    pkgconfig\(gdk-pixbuf-2.0\)

The exact package list varies per app — this one's just illustrative. Because the pipeline leans this heavily on cross-compilation, a handful of environment variables the toolchain normally sets for you had to be overridden by hand — left at their defaults, they'd point the linker back at the amd64 host instead of the aarch64 sysroot, and the build would fail.

C

C packages are built with zig cc — Zig's C compiler mode handles cross-compilation natively, without needing a separate cross-toolchain installed.

Go

Go packages just use the stock Go compiler, which cross-compiles for aarch64 out of the box — no extra setup needed there.

Debug packages

Debuginfo/debugsource packages need binutils-aarch64-linux-gnu, plus a few more environment variable overrides — an amd64 host's stock binutils can't correctly parse an aarch64 ELF binary on its own, so the aarch64-aware toolset has to be used explicitly instead.

All of this is open source — the full pipeline is up at git.jelius.dev/jelius-sama/kazuma-repository.

This is the first rpm packaging I've done, and while I've taken reasonable care, there are probably inconsistencies here that don't follow established rpm packaging idioms or best practices yet. If you run into one, I'll fix it as soon as I can — feel free to report it, whether you're a contributor or just passing through, at [email protected].

Version policy

For any package, I keep the latest version and the one right before it — so if a package is at 2.0.0, both 1.0.0 and 2.0.0 are available. That's the baseline, and there are a few exceptions on top of it.

Right after a release

When a new version lands, the package briefly has three: the previous two plus the one that was just released. Cleaning up the oldest happens later, and not on any schedule — it could be gone a minute from now or a month from now, so don't rely on a particular timeline.

example
steady state              1.0.0  2.0.0
3.0.0 just released       1.0.0  2.0.0  3.0.0
after cleanup (eventually)       2.0.0  3.0.0

Pinned for my own setup

Some packages need heavy configuration — neovim is the obvious one. If I haven't kept my dotfiles up with the latest releases and the newest version stops working with them, I pin the last version that still does. A pinned version stays until I decide otherwise, which could be tomorrow or never, so please don't depend on one being there.

Pin one for yourself

If you want your own pinned version of a package, clone the project, add it to the file that keeps track of pinned versions, and send a pull request. The git server here doesn't work the way GitHub does, though — the pull request goes out by email, and the walkthrough right below shows how.

Already comfortable sending patches by email? You can skip it.

Sending a patch by email

The code is readable on the open web, but it runs on my own server with account sign-ups turned off — I'm the only user. That means the usual "fork it and click New Pull Request" flow isn't available. Changes come in the way the Linux kernel takes them: as patches, sent by email. If you've never done that, here it is start to finish.

1. Install git's email tool

On Fedora it ships as its own package.

demo
❯ sudo dnf install git-email

2. Tell git who you are and how to send mail

You only do this once. It uses your own email provider's SMTP server — check its help pages for the exact server and port, and use an app password if it asks for one.

demo
❯ git config --global user.name "Your Name"
❯ git config --global user.email [email protected]
❯ git config --global sendemail.smtpServer smtp.your-provider.com
❯ git config --global sendemail.smtpServerPort 587
❯ git config --global sendemail.smtpEncryption tls
❯ git config --global sendemail.smtpUser [email protected]

3. Clone the repo and make your change

demo
❯ git clone https://git.jelius.dev/jelius-sama/kazuma-repository
❯ cd kazuma-repository
❯ git switch -c pin-my-package
# now edit `config.json` file that keeps track of pinned versions

4. Commit it

Say what you changed and, in the message body, why you need that version pinned — it helps me review it.

demo
❯ git add -A
❯ git commit -m "Pin neovim at 0.9.5"

5. Turn the commit into a patch and send it

format-patch turns your latest commit into an email-shaped .patch file, and send-email mails it. It shows you the message and asks for confirmation before anything goes out.

demo
❯ git format-patch -1 -o outgoing/
❯ git send-email [email protected] outgoing/*.patch

If send-email won't work with your provider, you can paste the contents of the .patch file into a plain-text email instead. Just make sure it's plain text — HTML email mangles patches.

6. What happens next

I'll review it and reply by email, sometimes asking for changes. To send a revised version, amend your commit and generate the patch again as version 2:

demo
❯ git commit --amend
❯ git format-patch -v2 -1 -o outgoing/
❯ git send-email [email protected] outgoing/v2-*.patch

Why I run my own repo

Every distro leans on someone else's mirrors for the packages it ships. I wanted the whole chain — build, storage, and delivery — to be something I actually run and understand. kazuma is that chain: a dnf repository I control end to end, starting with the aarch64 hardware I already had running.

Before you install

aarch64 only, for now. There's no amd64 build yet — the whole pipeline is hardcoded to one architecture while I get the plumbing right.

A handful of packages here are architecture-independent (noarch), but they're currently kept inside the aarch64 directory rather than a separate noarch one. That's not a packaging mistake — I just haven't built a per-architecture pipeline yet, so everything is routed through aarch64 until I do.

How it's compiled

Builds run on an amd64 machine sitting in my closet, set up as a Forgejo Actions runner. A push that bumps a package's version triggers a script that figures out what actually needs rebuilding, then the runner does the rest — no separate CI bill.

The interesting part is the target: everything I use day to day is aarch64 (my MacBook), but the runner itself is amd64. Rather than building natively inside an aarch64 container, every package has a spec file tuned to cross-compile for aarch64 straight from the amd64 host. That one decision took satty 0.22.0's build from 2h 8m 28s down to 23m 20s.

How it's hosted

Downloads run through a CDN in front of the actual storage, so pulling packages from here doesn't cost you anything and stays fast wherever you're pulling from. What isn't free is the storage side — every request still carries a small operational cost on the backend as the repo grows and gets used. Small per request, but a real cost all the same.

Chip in toward running costs

If this repo is useful to you, a small contribution helps cover the operational cost of keeping it running and growing. I haven't picked a donation platform yet — this button will point somewhere real soon.

Support this project Donation link coming soon