Cutefish OS is back, and this time it runs on Debian 13. The revived desktop has its own Wayland compositor, and its headline feature is Linux desktop AI agent computer use through cutefish-computer-use. That MCP server lets Claude Code or Codex see your screen, click and type, but only after you approve a dialog the agent can’t answer for you. In this test the agent calls came from a scripted MCP client announcing itself as claude-code, not a live Claude Code or Codex model session, because no model login was available. You’ll find the whole path here, from the nightly ISO to watching an agent pause when you touch the mouse. Cutefish also has an entry in our AI operating system roundup, alongside Ubuntu with inference snaps, deepin 25 and Windows 11.
This guide covers the Cutefish install in a Proxmox UEFI VM and what the system costs you in disk, RAM and boot time. You also get a desktop tour, the agent wiring for Claude Code MCP servers and Codex, and the APT route for Debian 13. There is no stable Cutefish OS 2026 release yet, so everything below uses the nightly build. I went through every step in November 2026 on the cutefish-1.0-nightly-20261101-1324 amd64 ISO, and they still hold for that build.
Know who builds Cutefish now
Cutefish today is the cutefishos GitHub organization’s revival of the 2021 CutefishOS project, and as of 3 November 2026, almost every commit I checked came from the reionwong account, the same handle as the original author, though other contributors have started committing since. That matters before you install anything, because the project’s legitimacy is being argued about in public and you deserve to see the evidence rather than a verdict.
The public record, checked through the GitHub API on 2 and 3 November 2026, mostly points one way. cutefish-core keeps its old history: its commits stop on 13 June 2023 and start again with commits dated 30 August 2026 (commit dates are set by the author, so treat them as approximate). cutefish-compositor and cutefish-toolkit are different. Both repositories were created in 2021. Their whole current history, though, begins with new imports dated 27 September and 14 October 2026, so the old Qt-era code is gone from their default branches. On those dates the last 100 commits on the toolkit and core, 99 of the last 100 on the compositor (the other one is from wineee), all 69 on packaging and all 9 on cutefish-computer-use came from reionwong, a public member of the org. A recheck on 11 November showed new names arriving: reionwong wrote 93 of the last 100 toolkit commits, 99 on core, 80 on the compositor and all 74 on packaging. The APT signing key you import later carries the UID Cutefish Archive <[email protected]>, and the download page says only the build workflow can sign with it.
On the other side, a 19 October 2026 post on r/CutefishOS titled “CutefishOS official sources” says new versions calling themselves Cutefish aren’t the official project or controlled by its development team. A 22 October thread on r/linux, “CutefishOS is back!!!”, points out that the original author’s account had started committing again. Commit metadata proves which account pushed the code, not which person sits behind it, so read it as strong evidence rather than proof. If provenance is a hard requirement for you, the build attestation in the next step is the part you can verify yourself.
Download and verify the Cutefish nightly ISO
The Cutefish download page keeps only the newest nightly ISO, and a small text file called LATEST-amd64 always holds its name. Reading that file first means your commands keep working when tomorrow’s build replaces today’s:
ISO=$(curl -fsSL https://download.cutefish.org/iso/nightly/LATEST-amd64)
echo "$ISO"
curl -fLO https://download.cutefish.org/iso/nightly/$ISO.iso
curl -fLO https://download.cutefish.org/iso/nightly/$ISO.iso.sha256
The name carries the build date and time, which is the only version number a nightly has, so write it down in case you need to report a bug later.
cutefish-1.0-nightly-20261101-1324-amd64
That ISO is 1,567,817,728 bytes, so about 1.6 GB, and a download cut short is the usual reason a live ISO refuses to boot. Check it against the published checksum before you do anything else with it.
sha256sum -c $ISO.iso.sha256
A matching file prints one line ending in OK. A checksum only proves the file arrived intact, though, because whoever controls the server controls both files. The attestation check proves something stronger: that a GitHub Actions run in cutefishos/packaging built this exact file.
Install a GitHub CLI that knows attestations
You need GitHub CLI 2.49 or newer for gh attestation, and Debian 13’s own gh package is 2.46.0, which is too old. On Debian or Ubuntu, add GitHub’s own repository instead, which currently ships 2.103.3. On any other workstation, use the install method for your OS from the GitHub CLI README.
sudo apt install -y wget
sudo mkdir -p -m 755 /etc/apt/keyrings
wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null
sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
sudo apt update
sudo apt install -y gh jq
Confirm the version before you go on, because the attestation step depends on it and anything older than 2.49 won’t have the subcommand.
gh --version
If you see gh version 2.103.3 (2026-10-26) or newer, as the lab box did, you’re using the package from GitHub’s repository.
Error: “To get started with GitHub CLI, please run: gh auth login”
The download page tells you to run gh attestation verify $ISO.iso --repo cutefishos/packaging, and on a machine that has never signed in to GitHub it stops straight away with exit code 4:
To get started with GitHub CLI, please run: gh auth login
Alternatively, populate the GH_TOKEN environment variable with a GitHub API authentication token.
You have two ways out. If you already have a GitHub account, gh auth login and the original command is the short path. If you’d rather not log a test box in to GitHub, fetch the attestation bundle from the public API (no token needed for a public repository) and verify it without logging in. gh still downloads Sigstore’s trusted root, so the machine needs internet access.
DIGEST=$(sha256sum $ISO.iso | cut -d' ' -f1)
curl -fsSL https://api.github.com/repos/cutefishos/packaging/attestations/sha256:$DIGEST | jq -c '.attestations[].bundle' > cutefish.sigstore.jsonl
gh attestation verify $ISO.iso --bundle cutefish.sigstore.jsonl --repo cutefishos/packaging
Look for Verification succeeded! and a build workflow of .github/workflows/iso.yml@refs/heads/main, because that pair tells you the file came out of the public workflow on the main branch and not from someone’s laptop. If either line is missing, delete the ISO and download it again. Both checks passed on the lab copy.

If you want the exact commit behind the ISO, ask for JSON and pull the two fields that matter.
gh attestation verify $ISO.iso --bundle cutefish.sigstore.jsonl --repo cutefishos/packaging --format json | jq '.[0].verificationResult.signature.certificate | {sourceRepositoryDigest, runInvocationURI}'
For this build the certificate named source commit 4bf91872f80f63d1e7c2c9a888ba92b20fb6f3d4 on main and Actions run 41311110667, which you can open on GitHub and read line by line.
Install Cutefish in a Proxmox UEFI VM
Cutefish installs on UEFI firmware, and it boots fine with Secure Boot keys enrolled, because the installer puts Debian’s signed shim, GRUB and kernel on the disk. These are the VM settings that worked on Proxmox VE 8.4:
- You’ve set BIOS to OVMF (UEFI) and machine type to q35.
- You’ve added an EFI disk with pre-enrolled keys, which turns Secure Boot on.
- You’ve given it a 32 GB VirtIO SCSI disk, 4 vCPUs with CPU type host, and 8 GB of RAM.
- You’ve picked VirtIO-GPU or the standard VGA display, both of which drove the compositor.
One honest note about the lab. The lab account can’t upload ISOs to the Proxmox nodes, so the installer ran under QEMU with OVMF inside a lab VM. It wrote straight to that VM’s second Proxmox disk. Afterwards the same VM was switched to OVMF with that disk as its boot device, and every boot, memory and Secure Boot number below comes from that native run. If you’re new to Proxmox guests, the Omarchy on Proxmox walkthrough shows the same OVMF settings in the web UI.
Boot the ISO and the welcome screen appears without a boot menu or a language picker. That surprises people coming from other distros, but it’s normal here, since the installer simply doesn’t ask for a language or keyboard layout.

Try Cutefish opens the live desktop, and Next starts the installer. The next page, Choose a Disk, lists the drives and says plainly that Cutefish uses the whole disk. A Partition manually box is there if you need it, but nothing else on that page needs a decision.
The account page is the part that trips people up, because the computer name becomes your hostname and you can’t skip any field. Pick both carefully, since changing a hostname later means editing /etc/hostname and /etc/hosts by hand.

- 1User name
- 2Computer name
- 3Continue
- User name is your login, lowercase, used for your home folder.
- Computer name becomes the hostname, so you’ll see it in every terminal prompt.
- Continue stays greyed out until all five fields are filled and both passwords match.
The time zone page has a search box, so typing “Nairobi” or your own city is faster than scrolling. Then you reach the summary, which is your last chance to back out:

- 1Disk
- 2Erase Disk and Install
- Disk shows the drive that gets wiped. On a VirtIO disk it shows the PCI vendor ID
0x1af4and the size instead of a model name, and there’s no automatic install-alongside option, so check this row twice on real hardware. - Erase Disk and Install starts the copy. It took under three minutes in the lab, and you then get a “Cutefish Is Installed” screen with Restart Now.
Detach the ISO from the VM’s CD drive before you click Restart Now, because the VM will otherwise boot the live image again and you’ll land back on the welcome screen. On bare metal, pull the USB stick at the same moment.
UEFI Interactive Shell after the installer restarts
My first reboot dropped into the Shell> prompt of the UEFI Interactive Shell. The disk was fine: listing it showed \EFI\BOOT\BOOTX64.EFI and \EFI\debian, which is the fallback loader any UEFI firmware can find. The VM’s boot order simply still pointed at the CD drive, and with the ISO ejected the firmware gave up. Put the disk first in the VM’s boot order (on Proxmox, Options then Boot Order) and power the VM off and on again. Because the installer writes that fallback path, a brand new EFI disk with no saved boot entries still boots Cutefish, which is exactly what happened in the native Proxmox run.
Measure what Cutefish costs
A fresh Cutefish install boots to its login screen in about 6 seconds and idles at around 800 MB of RAM. The compositor alone holds about 275 MiB of that, so budget at least 4 GB for a VM you plan to actually use. The boot, RAM and Secure Boot rows come from the native Proxmox VM (4 vCPU, 8 GB, ZFS-backed disk); install time and disk use come from the first run that installed and booted the same disk.
| What | Measured | How |
|---|---|---|
| ISO size | 1,567,817,728 bytes (1.6 GB) | ls -l on the download |
| Install time | Under 3 minutes | Erase Disk and Install to the done screen |
| Disk layout | 512 MB EFI partition plus one ext4 root, no swap partition | lsblk |
| Swap | zram, half of RAM (3.9 GB on 8 GB) | /proc/swaps |
| Disk used | 3.8 GB at first boot, before the agent CLIs; Node.js, Codex and Claude Code (314 MB of it Claude Code) took it to 4.7 GB in the native run | df -h / and du after first login |
| Boot to graphical target | 6.252 s (2.923 s kernel, 3.328 s userspace) | systemd-analyze |
| RAM at the login screen | 557 MB used | free -m |
| RAM at idle desktop | 817 MB used, two minutes after login | free -m |
| Largest process | cutefish-compositor, 281,136 KiB RSS (about 275 MiB) | ps sorted by RSS |
| Secure Boot | On, kernel locked down | dmesg |
Run the same three checks on your own install to compare. A slower disk or a real GPU moves these numbers more than anything Cutefish does, so your laptop may well beat the VM.
systemd-analyze
free -m
ps -eo rss,comm --sort=-rss | head -4
You can compare yours with what the Proxmox VM printed after two idle minutes at the desktop.

The 6.25 seconds doesn’t include firmware time, because systemd-analyze can’t see OVMF on a GRUB boot, so add a second or two for the boot logo on real hardware. The same desktop on a 4 GB VM used 722 MB, which tells you most of that memory is the shell itself and not cache that grows with the RAM you give it. One more surprise: /etc/os-release reads plain “Debian GNU/Linux 13 (trixie)” with DEBIAN_VERSION_FULL=13.7, so tools that branch on the distro ID treat Cutefish as Debian.
Find your way around the Cutefish desktop
If you’ve used a Mac, you already know the layout. The active app’s menus sit in a bar at the top, the status area is on the right, and the Dock at the bottom starts with the launcher. The first login takes you straight to an empty desktop with no welcome app or setup wizard:

Click the rocket in the Dock to open the launcher. Every installed app sits in one grid with a search field at the top, and Escape closes it:

The nightly ships eleven launcher entries: Calculator, Calendar, Chromium Web Browser, Fcitx 5 Configuration, Files, Screenshot, Settings, System Monitor, Terminal, Text Editor and Video Player. Chromium is the one you’ll use most that isn’t Cutefish’s own. There’s no office suite, mail client or software store, so plan on apt for everything else.
Desks are Cutefish’s name for workspaces. Press Ctrl+Up to open the overview, which shows your windows spread out and a strip of desks along the top:

- 1Desk 2
- 2Add a desk
- Desk 2 is a second desk; click its thumbnail to switch to it.
- Add a desk with the plus tile at the end of the strip.
The shortcut key is Command, which on a PC keyboard is the Super (Windows) key, and apps treat Super and Ctrl the same for copy and paste. The full shortcut list came from the system itself (the MCP server below exposes it), and these are the ones you’ll use daily:
| Action | Shortcut |
|---|---|
| Overview of windows and desks | Ctrl+Up |
| Switch apps | Super+Tab |
| Desk to the left or right | Ctrl+Super+[ or Ctrl+Super+] |
| Jump to desk 1 to 8 | Ctrl+Super+1 to Ctrl+Super+8 |
| Quit the app | Super+Q |
| Lock the screen | Ctrl+Super+Q |
| Screenshot of a region | Shift+Super+4 |
| Clipboard history | Ctrl+Super+V |
The new-desk shortcut (Ctrl+Super+=) didn’t create a desk when it was sent through the VM console, so use the plus tile in the overview if it does nothing for you either.
Check the “no Qt, no GTK” claim yourself
Cutefish says every one of its apps is built on cutefish-toolkit, a C++ toolkit drawn with Skia, and the binaries back that up. The compositor, Files and Terminal link only the Cutefish toolkit libraries, with no Qt or GTK library in their dependencies:
ldd /usr/bin/cutefish-compositor | grep -E "Qt6|gtk|cutefish-toolkit"
You get only the two toolkit libraries back, and Files and Terminal give you the same pair.
libcutefish-toolkit.so.1
libcutefish-toolkit-base.so.1
Qt 6 and GTK 3 and 4 are still installed, though. Qt arrives through cutefish-qt-plugins, which makes Qt apps scroll the Cutefish way, and GTK is pulled in by ordinary Debian dependencies such as Chromium and the Fcitx 5 input method frontends. So “no Qt or GTK” is true of the desktop’s own code, not of the disk, and that’s a reasonable trade if you want third-party apps to fit in.
System Monitor is the quickest way to see what’s running and what each part costs. In the first run the compositor sat at the top at around 290 MiB, which is expected, because it draws the shell, the Dock and every blur effect itself.

Files, the services daemon and the polkit agent each hold 80 to 150 MiB, which accounts for most of the idle figure in the table above. None of them can be switched off without losing a core part of the desktop, so 4 GB is the realistic floor for a VM.
Let Claude Code drive the desktop with cutefish-computer-use
One note on method first: the agent calls in this section were driven by a scripted MCP client announcing itself as claude-code, not by a live Claude Code or Codex model session, since the lab had no model login. cutefish-computer-use is a Rust MCP server that ships with Cutefish and talks to the compositor directly. Your agent sees real screenshots and sends real clicks, with no screen recorder or fake keyboard in between. The compositor only offers control to the binary at /usr/bin/cutefish-computer-use, asks you before every session, and stays in charge of when the agent may act. It’s already installed on the ISO, and on the APT route it comes in as a recommended package.
Install Claude Code with the native installer if you don’t have it yet (our Claude Code install guide covers the apt and npm options too). The installer puts claude in ~/.local/bin, which isn’t on your PATH until you log in again, so add it now:
curl -fsSL https://claude.ai/install.sh | bash
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
Then register the server. It’s a stdio server, so the command after -- is all Claude Code needs. Run claude from Cutefish’s own Terminal, because the server reaches the compositor through the session’s WAYLAND_DISPLAY; over SSH I had to export XDG_RUNTIME_DIR=/run/user/1000 and WAYLAND_DISPLAY=cutefish-0 first.
claude mcp add cutefish -- /usr/bin/cutefish-computer-use
claude mcp list
You should see the server marked Connected. The capture also shows codex mcp list from the Codex steps further down, where the same server shows as enabled.

Notice the “local config” in that output. Claude Code saved the server for your home folder only, so a claude session started inside a project directory won’t see it. Add --scope user to the claude mcp add line when you want it everywhere.
For Codex, install the CLI from npm first, since Cutefish ships neither Node.js nor Codex. The ISO also has only vim-tiny. That means vim returns “command not found” until you add the full package, though vi and nano work. These commands cover both and open the config file:
sudo apt install -y nodejs npm vim
sudo npm install -g @openai/codex
mkdir -p ~/.codex
vim ~/.codex/config.toml
Add the server block. That’s the whole configuration Codex needs, and you can write it with nano instead if you’d rather not install vim.
[mcp_servers.cutefish]
command = "/usr/bin/cutefish-computer-use"
Codex 0.166.0 listed it as enabled straight away. If you’re choosing between the two agents for desktop work, the OpenCode vs Claude Code vs Codex comparison covers how they differ on everything else.
You should know how the rest of this section was tested. The lab VM had no Claude or OpenAI login. So instead of a model, a small MCP client drove the server, sending the same JSON-RPC calls an agent sends over stdio and announcing itself as claude-code. Every dialog, button and error below is what the compositor did with those real calls. Only the model’s own choice of what to click wasn’t exercised.
Approve the compositor consent dialog
Connecting the server does not trigger anything, which is why claude mcp list showed Connected without a prompt. The first tool call that needs the screen, usually a screenshot, makes the compositor stop and ask you, and the agent’s call simply waits until you answer.

- 1Cancel
- 2Allow
- Cancel refuses, and the agent gets “The user did not allow control of the computer. Do not ask again unless the user asks you to.”
- Allow hands over control until you press Stop or the agent’s session ends.
The Cutefish blog shows an “Always allow this app” checkbox in this dialog, but the 1 November nightly doesn’t have it. You’ll be asked at the start of every agent session. That’s annoying for long jobs and reassuring for everything else. The page that would list always-allowed apps already exists in Settings:

- 1Search for Privacy
- 2Computer control
- Search for Privacy in the Settings search field; the page sits under System.
- Computer control lists apps allowed without asking, and on this build it says none are.
Pay attention to the name in the dialog, because it comes from the agent. The test client called itself claude-code and the dialog repeated that word for word, while the icon switched to the Terminal icon once the client was launched from Terminal. Treat the name as a label the agent chose and the icon as a hint about where it runs, and only allow a session you started yourself a moment earlier.
Stop the agent from the status bar
While an agent has control, a Stop button appears in the status bar next to the clock, and it disappears the moment control ends. In this capture the agent had just typed into Text Editor:

- The Stop button ends control for the whole session with one click.
Pressing it doesn’t kill the agent process, so the agent keeps running and its next action has to fail cleanly. In the test, its next type_text call came back as an error instead of typing.
The user stopped your control of the computer. Do not continue unless the user asks you to.
The call after that, a screenshot, raised a fresh consent dialog. Nobody answered it, and two minutes later the agent got “The user did not answer the permission prompt in time.” So Stop really is a stop. The agent has to ask you again, and it can’t wait you out.
Take the keyboard back mid-task
Cutefish promises that your own input pauses the agent, and the easiest way to see it is a held key. I had the agent hold the period key in Text Editor twice (12 seconds requested, which the server caps at 10): once while I kept moving the mouse, and once with my hands off. The difference is obvious on screen:

Line 2 got 31 periods because the hold paused while the pointer moved. Line 3 got 239 because nobody touched anything. (The “typed after Stop?” words on line 2 come from that first run, before Stop was pressed at all.) The agent’s hold_keys call still reported “Held.” both times, so a model won’t necessarily know it was interrupted. If you grab the mouse to stop something, press Stop as well rather than trusting the pause to end the task.
See what the agent can’t touch
Password and permission prompts are off limits to the agent, and that held up in the test even when the agent did everything right on paper. I had it open Terminal and run pkexec true, which pops up the polkit password dialog, then click the field, type a password and press Return:

The field stayed empty. The agent’s own screenshot showed the dialog clearly, yet its click, typing and Return all came back as “Clicked.”, “Typed.” and “Pressed.” with nothing landing anywhere. That’s the right outcome for safety, but it’s silent, so expect an agent to think it typed a password and get confused when nothing happens. A second agent can’t sneak in either: while one session waited for consent, another client’s click returned “Another app is controlling the computer.”
Within those limits the server gives an agent 22 tools. The server’s own instructions tell the agent to take a screenshot first, because every coordinate it sends refers to the latest screenshot, so you’ll see that call at the start of every session. Here they are, grouped the way you’d use them.
| Group | Tools | What the test showed |
|---|---|---|
| See | screenshot, zoom, cursor_position | Screenshots arrive as 1430×804 JPEG from a 1920×1080 screen |
| Point | click, move_pointer, drag, mouse_down, mouse_up, scroll | Coordinates are pixels of the latest screenshot |
| Type | type_text, press_keys, hold_keys, set_clipboard, keyboard_shortcuts | A 285-character sentence typed in under a second |
| Windows and apps | list_windows, activate_window, close_window, set_window_frame, list_applications, open_application, open | open_application waits for the window and returns its number |
| Batch | actions | Runs several steps in one call |
For day-to-day use, the Cutefish setup post suggests allowing mcp__cutefish with /permissions in Claude Code so you aren’t asked per tool. That part needs a Claude login, so it wasn’t tried here. Either way, the Cutefish dialog still decides whether the agent gets the desktop at all. The Claude Code cheat sheet lists the other permission commands if you want tighter rules.
Add Cutefish Desktop to plain Debian 13
If you already run Debian 13 (trixie), you don’t need the ISO. The same nightly packages sit in an APT repository at download.cutefish.org, and cutefish-desktop pulls in the compositor, the apps, the display manager and the agent server. Start with the signing key; minimal installs and cloud images don’t have gpg, and the fingerprint check fails with gpg: command not found, so install it first:
sudo apt install -y gnupg curl
sudo curl -fsSLo /etc/apt/keyrings/cutefish.asc https://download.cutefish.org/debian/cutefish.asc
gpg --show-keys /etc/apt/keyrings/cutefish.asc
Compare the fingerprint with the one on the download page, 5F52 7F0C B976 4BA0 AF99 BAE5 F4A4 30BC 9E10 91A7, before you trust it. APT trusts whatever key sits in that file, so this comparison is the only thing standing between you and a swapped key.
pub ed25519 2026-10-19 [SC]
5F527F0CB9764BA0AF99BAE5F4A430BC9E1091A7
uid Cutefish Archive <[email protected]>
Add the repository and install the desktop. The suite is trixie-nightly, which is the only channel there is right now:
echo "deb [signed-by=/etc/apt/keyrings/cutefish.asc] https://download.cutefish.org/debian trixie-nightly main" | sudo tee /etc/apt/sources.list.d/cutefish.list
sudo apt update
sudo apt install -y cutefish-desktop
On a minimal Debian 13 VM that meant 214 new packages, a 176 MB download and 534 MB of disk, and the whole install took 207 seconds. The part that trips people up comes right after: cutefish-dm is installed but left disabled, so a reboot lands you on a text console. Enable it yourself. The lab machine had no other display manager; if yours already runs GDM or SDDM, disable that one first so the two don’t compete for the screen.
sudo systemctl enable cutefish-dm
The capture shows the whole route on the lab box, from the key fingerprint to the display manager symlink. Notice that cutefish-computer-use was set up too, because cutefish-desktop recommends it and APT installs recommends by default.

Reboot, and if your machine runs Debian’s standard kernel you’ll get the Cutefish login screen. If it doesn’t, read the next part before you start debugging the compositor.
Black text console: the greeter restarts every five seconds
My test box was built from a Debian cloud image, and after the reboot the console stayed on boot messages while cutefish-dm reported itself active. Its journal showed the greeter session opening and closing every five seconds, and ls /dev/dri returned “No such file or directory”. Debian’s -cloud-amd64 kernel leaves out the DRM graphics drivers, so the compositor has no display to draw on. Install the standard kernel and make sure GRUB boots it:
sudo apt install -y linux-image-amd64
GRUB keeps the cloud kernel as its first entry, so list the menu entries and count where the standard kernel sits:
sudo grep -E "^\s*(menuentry|submenu)" /boot/grub/grub.cfg | cut -c1-90
On the lab box the plain -amd64 kernel was the third entry (counting from 0, that’s 2) inside the second top-level item, the “Advanced options” submenu (1). GRUB writes that as 1>2, so set it as the default, regenerate the menu and reboot:
sudo sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT="1>2"/' /etc/default/grub
sudo update-grub
sudo systemctl reboot
With 6.12.115+deb13.1-amd64 running, /dev/dri/card0 appeared and the greeter came up on the Proxmox console:

A desktop or laptop installed from the regular Debian ISO already runs linux-image-amd64, so you’ll only hit this on cloud images and VPS templates. If you’re not sure which one you have, uname -r tells you, since the cloud build ends in -cloud-amd64.
Check whether Mac apps (Reef) are in your build
Reef, the layer that runs Mac apps from their .dmg disk images, isn’t in any build you can download yet. The Cutefish post Mac apps on Cutefish: the first milestone (2 November 2026) shows NetNewsWire, Ghostty, CotEditor, Keka and Speedtest running, and says Reef “will ship in Cutefish as soon as possible”; the Cutefish home page calls those development builds. Linuxiac adds that Reef is not currently open source, unlike the rest of the desktop.
You can check your own install in a few seconds, which is worth doing before you go looking for a Mac app option that isn’t there.
dpkg -l | grep -ci reef
apt-cache search reef | grep -i cutefish
On the 1 November nightly the first command prints 0 and the second prints nothing, and the APT repository’s 21 Cutefish packages don’t include it either. When a Reef package does appear, you’ll see it in apt-cache search cutefish after an apt update, and the blog describes the install as opening the .dmg in Files, where it mounts under Locations, then dragging the app into your Applications folder.
Common misconceptions about Cutefish
A few things in the launch coverage don’t match what the nightly actually does, and they change how you should use it.
- You’re running a nightly build, not a Cutefish 1.0 final release.
- You still get Qt 6 and GTK on disk, even though Cutefish’s own apps don’t use them.
- You can’t treat the name in the consent dialog as a verified identity.
- You aren’t installing the 2021-2022 CutefishOS (Ubuntu, later Debian 11), so its old guides don’t apply.
The download page itself says “nothing here is an official release yet” and keeps only the newest ISO, so save the exact file name you tested if you ever need to reproduce a problem. The Qt and GTK libraries come in through the Qt plugin package, Chromium and the input method frontends, which is a fair trade if you run third-party apps. The consent name is whatever the MCP client sends, which is how a test client showed up as “claude-code”, so judge a prompt by whether you just started an agent. If you really need the old system, our guide to the older Ubuntu 22.04 based CutefishOS YoYo build covers its installer and the fix for a black screen after reboot.
If you want a Mac-like Linux desktop to try in a VM this week, Cutefish is worth the 1.6 GB download. Its agent controls are worth studying even if you never switch desktops, because consent, Stop and input-pause live in the compositor where the agent can’t reach them. For a machine you depend on, wait for a tagged release and look at the stable options in our list of best Linux desktop distributions in the meantime.