Amber Linux
A collection of applications, services, themes, and tutorials for sharing AI agents on top of Linux Mint.
Applications
Native Linux Mint apps designed to make AI agents feel at home on your desktop — not bolted on from a cloud dashboard.
Services
DBus and system services that expose your machine's context — clipboard, notes, files — to agents running locally.
Themes
Cohesive desktop themes so your AI-native workspace feels intentional, not like a collection of mismatched tools.
Tutorials
Step-by-step guides for building, deploying, and sharing AI agents on Linux Mint using the Amber Linux stack.
Projects
Kat800
AppA terminal multiplexer built for AI agent workflows on Linux Mint. Run multiple agents, monitor sessions, and orchestrate pipelines — all from one terminal.
KatKlips
ServiceA DBus service for Linux Mint that manages your clipboard history, bookmarks, and notes — making context instantly available to AI agents running on your system.
Amber Phosphorus
ThemeA Linux Mint theme inspired by the warm amber glow of 1990s CRT phosphor monitors. Brings a coherent, nostalgic aesthetic to your entire Mint desktop.
Amber LIB
LibraryThe Amber Linux package library for Odin. Go-modelled packages for filesystem paths, HTTP, DBus, GTK4, PTYs and more, with allocator-aware APIs throughout.
Amberlin
AppA centered Spotlight-style GTK4 launcher for Linux Mint Cinnamon. Search KatKlips clipboard history, pick an entry, and paste it back into your workflow.
Amber Odin
PackageA Debian package wrapper for the upstream Odin compiler. Installs a predictable /usr/bin/odin on Linux Mint without colliding with Ubuntu's unrelated odin package.
Odin — The Amber Linux Language
Amber Linux is written in Odin — a systems programming language created by Ginger Bill over the last ten years. Every tool in the stack — Kat800, KatKlips, Amberlin, Amber Phosphorus, and Amber LIB — is built with a predictable Amber Odin compiler package and shared Odin collections. Together they make the case for Odin as the first choice when writing native Linux Mint applications: near-C performance, effortless C bindings, and code that is genuinely a pleasure to read and write.
Near-C performance
Odin compiles to native machine code with no garbage collector and no hidden allocations. Memory is managed through explicit allocators — arenas, pools, stacks — that you choose per-subsystem. Linux Mint applications written in Odin have the same runtime profile as their C equivalents, with none of the footguns.
Effortless C bindings
The foreign keyword makes calling any C library a matter of a single
declaration. GTK4, libvte, GLib, DBus-GLib — the entire Linux desktop stack is
immediately available. No wrapper generators, no FFI scaffolding, no C header
translation scripts. Declare it, call it, ship it.
Beautiful syntax
Odin reads like the language you always wished C would become. Procedures, packages, distinct types, multiple return values, tagged unions, and a context system for allocators and logging — all expressed without boilerplate. Code that is easy to read is code that is easy to maintain. Odin takes that seriously.
Linux-native by design
Odin's core library includes POSIX bindings, a core:sys/linux package
for direct syscalls, and first-class support for building shared libraries. Everything
you need to write applications that integrate with the operating system rather than
working around it.
package amber_app
import "core:fmt"
import gtk "vendor:gtk/gtk4"
// C bindings: declare with the foreign keyword and call immediately.
// No scaffolding. No wrapper generation.
@(default_calling_convention = "c")
foreign gtk.lib {
gtk_window_set_title :: proc(win: ^gtk.Window, title: cstring) ---
gtk_window_present :: proc(win: ^gtk.Window) ---
}
// Multiple return values instead of exceptions or error types.
// The caller decides what to do with the failure case.
read_clipboard :: proc() -> (text: string, ok: bool) {
raw := katklips_get_current() // DBus call via foreign binding
if raw == nil { return "", false }
return string(raw), true
}
activate :: proc(app: ^gtk.Application, _: rawptr) {
win := gtk.application_window_new(app)
gtk_window_set_title(win, "Amber App")
if clip, ok := read_clipboard(); ok {
fmt.printfln("Clipboard context loaded: %s", clip)
}
gtk_window_present(win)
}
main :: proc() {
app := gtk.application_new("com.amberlinux.example", .FLAGS_NONE)
defer gtk.g_object_unref(app) // defer: cleanup on scope exit
gtk.g_signal_connect(app, "activate", activate, nil)
gtk.application_run(app, 0, nil)
}Ginger Bill's ten-year achievement
Odin is the work of Ginger Bill (Bill Hall), who began the language around 2016 with a conviction that systems programmers deserved something better than C — not a language that hid what it did behind abstractions, but one that was honest, fast by default, and genuinely pleasant to write. No hidden allocations. No surprise garbage collection pauses. No boilerplate inherited from decades of backwards compatibility decisions nobody wanted to own.
Ten years later, Odin is a mature, production-ready language with a comprehensive core and vendor library, a compiler that produces excellent code, and a reputation in the game development and systems programming communities for being the language people actually enjoy coming back to. That is a rare thing. Most languages are tools you tolerate. Odin is a language you look forward to working in.
Amber Linux bets on Odin as the right foundation for native Linux Mint software. The vision is simple: Odin should be the first language a developer reaches for when they want to write a Linux Mint application — not because there is no choice, but because it is the best one.