August 25, 2025

Develop apps for Omarchy (with Flutter)

Aloïs Deniel

Develop apps for Omarchy (with Flutter)

This story starts at 4:30 in the morning.

My daughter had just woken me up, and after helping her settle back to sleep, I found myself wide awake. Instead of returning to bed, I went hunting for an old computer I had stashed away. Why? Because I had recently stumbled across Omarchy, the Arch-based Linux distribution from DHH (yes, the creator of Ruby on Rails), and I couldn’t shake the idea of trying it out for myself.

There’s something about discovering a new, beautifully crafted operating system that makes you feel like a kid again. The promise of a lean, polished Linux setup—without the painful hours of configuration—was too tempting. So, there I was in the quiet of the morning, coffee in hand, ready to see what Omarchy was all about and whether I could build apps for it with Flutter.

Spoiler: I could. And it was easier than I expected.

What is Omarchy?

Omarchy is an opinionated configuration for Arch Linux.

If you’ve ever installed Arch, you know the drill: full control, but at the price of a steep learning curve. Omarchy flips the script. Instead of wrestling with configs for hours, you get a refined, ready-to-go setup in minutes—straight from DHH’s personal configuration.

I didn’t realize Linux could feel this smooth until I tried Omarchy. Honestly, it made me think: Could I actually switch from macOS? With Omarchy, the answer suddenly didn’t feel so far-fetched.

The installation itself is straightforward (the official guide is excellent), but here’s the short version:

  1. Create a bootable USB stick.
  2. Install Arch Linux with the suggested settings.
  3. Run the Omarchy setup script.
  4. Voilà — welcome to Omarchy!

Why Flutter?

Flutter started as a mobile toolkit, but it has matured into a great option for desktop development too.

Here’s why it pairs beautifully with Omarchy:

  • Cross-platform: One codebase for Linux, macOS, Windows, and mobile.
  • Fast & efficient: Native performance, no Electron bloat.
  • Linux-friendly: Canonical (Ubuntu) actively contributes to Flutter’s Linux tooling.
  • Battle-tested: Omarchy itself ships with a Flutter app I love — LocalSend.
  • Developer joy: Hot reload, rich widgets, and an approachable API.

So let’s walk through how to get Flutter up and running on Omarchy—and then we’ll build an app that looks and feels right at home.

Installing Flutter on Omarchy

Omarchy includes a lot of developer tools by default, but Flutter isn’t one of them (yet). Thankfully, installation is easy. Just run:

sudo pacman -Syu --needed xz glu
sudo pacman -S --needed clang cmake ninja pkgconf gtk3 xz gcc
mise plugins install flutter https://github.com/mise-plugins/mise-flutter.git
mise use -g flutter@latest

Once it’s installed, check your setup with:

flutter doctor

If you see warnings, follow the suggestions to fix them before moving on.

Configuring Neovim for Flutter

Omarchy ships with Neovim, specifically LazyVim, a beautifully preconfigured environment.

To add Flutter/Dart support, create this file:

~/.config/nvim/lua/plugins/flutter.lua

With this content:

return {
  {
    "neovim/nvim-lspconfig",
    opts = function()
      require("lspconfig").dartls.setup({
        cmd = { "dart", "language-server", "--protocol=lsp" },
      })
    end,
  },
}

Restart Neovim, and you’ll have autocompletion, inline errors, and more for Dart/Flutter.

From Hello World to Omarchy Native

With Flutter installed and Neovim ready, let’s spin up your first app:

flutter create example
cd example
flutter run

Boom—you’ve got the default counter app running in Omarchy.

But here’s the thing: it still looks like a mobile app. Material Design doesn’t quite match Omarchy’s minimalist elegance. So let’s give it a true Omarchy look and feel.

Applying the Omarchy Look

There are two big steps to making your app feel like it belongs in Omarchy:

  1. Cleaning up the window chrome.
  2. Using a UI toolkit that actually matches Omarchy’s design language.

Removing the Window Title Bar

By default, Flutter desktop apps are GTK windows with a chunky title bar. To strip it down, edit linux/runner/my_application.cc.

Simply delete the part related to the header bar:

  // Use a header bar when running in GNOME as this is the common style used
  // by applications and is the setup most users will be using (e.g. Ubuntu
  // desktop).
  // If running on X and not using GNOME then just use a traditional title bar
  // in case the window manager does more exotic layout, e.g. tiling.
  // If running on Wayland assume the header bar will work (may need changing
  // if future cases occur).
  gboolean use_header_bar = TRUE;
#ifdef GDK_WINDOWING_X11
  GdkScreen* screen = gtk_window_get_screen(window);
  if (GDK_IS_X11_SCREEN(screen)) {
    const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
    if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
      use_header_bar = FALSE;
    }
  }
#endif
  if (use_header_bar) {
    GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
    gtk_widget_show(GTK_WIDGET(header_bar));
    gtk_header_bar_set_title(header_bar, "example2");
    gtk_header_bar_set_show_close_button(header_bar, TRUE);
    gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
  } else {
    gtk_window_set_title(window, "example2");
  }

Rebuild the app, and suddenly you’ve got a borderless, clean slate to design your own Omarchy-style controls.

Exploring Desktop Design Systems

When it comes to UI packages, you’ve got options:

  • shadcn_flutter: Modern, clean, dark-mode friendly — fits Omarchy pretty well.
  • yaru: Ubuntu's official design system from Canonical
  • macos_ui: Perfect if you prefer the Apple aesthetic.
  • fluent_ui: For fans of Windows’ Fluent Design.

But… none of them quite captured Omarchy’s particular blend of minimalism and utility.

Enter flutter_omarchy

That’s why I built flutter_omarchy — a lightweight Flutter package that brings Omarchy’s design language to your apps.

It includes:

  • Native-feeling components
  • Theme consistency (colors adapt to user preferences automatically)

Styling Our Counter App

Let’s bring our default counter app to life with flutter_omarchy.

First, to add the dependency run:

flutter pub add flutter_omarchy

Then wrap your app with OmarchyApp:

import 'package:flutter/material.dart';
import 'package:flutter_omarchy/flutter_omarchy.dart';

void main() async {
  await Omarchy.initialize();
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return OmarchyApp(
      home: const MyHomePage(title: 'Counter'),
    );
  }
}

And update your counter page:

@override
Widget build(BuildContext context) {
  return OmarchyScaffold(
    navigationBar: OmarchyNavigationBar(title: Text('Counter')),
    child: Center(
      child: Column(
        spacing: 24,
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          const Text('You have pushed the button this many times:'),
          Text(
            key: ValueKey(_counter),
            '$_counter',
            style: TextStyle(fontSize: 92),
          ),
          OmarchyButton(
            onPressed: _incrementCounter,
            child: const Icon(OmarchyIcons.codAdd, size: 42),
          ),
        ],
      ),
    ),
  );
}

And voilà — now your counter app looks like it was built for Omarchy from day one.

More Examples

The flutter_omarchy web gallery includes plenty of examples, all running in the browser thanks to Flutter’s web support.

Each comes with source code you can reuse or tweak for your own apps.

A Note on Maturity

That said, flutter_omarchy is still in its early days. The foundations are there, but it’s far from feature-complete — many widgets and behaviors you’d expect are either missing or still rough around the edges. If you give it a try, expect some gaps, and don’t hesitate to contribute or open issues. The more people experiment with it, the faster it will grow into a polished toolkit worthy of Omarchy itself.

Going Further

This walkthrough just scratches the surface. For more widgets and advanced APIs, check the official Flutter docs.

But here’s the bigger picture: Omarchy isn’t just a Linux distro. It’s a vision of what computing could be — open, elegant, and developer-friendly.

By building apps for it, we’re not just tinkering with another desktop environment. We’re contributing to a future where freedom and beauty go hand in hand.

So grab your editor, fire up Flutter, and build something beautiful for Omarchy.

Happy coding!

← Back to all articles